Video ini membahas type system di Dart, khususnya tiga konsep yang saling berhubungan:

1. Type inference → bagaimana Dart mengetahui tipe variable secara otomatis.
2. Type safety → bagaimana Dart mencegah kita memasukkan atau menggunakan data dengan tipe yang salah.
3. Sound type system / sound typing → gabungan static checking dan runtime checking untuk menjaga keamanan tipe.

Ada beberapa bagian transkrip yang agak membingungkan, terutama soal dynamic dan null. Jadi saya akan jelaskan dengan versi yang lebih akurat dan mudah dipahami.

1. Apakah Type Wajib di Dart?

Video dimulai dengan pertanyaan:

“Apakah tipe data wajib ditulis untuk setiap variable di Dart?”

Jawabannya:

Setiap nilai/variable di Dart memiliki tipe, tetapi kita tidak selalu harus menuliskan tipe tersebut secara eksplisit.

Ini perbedaan yang sangat penting.

Contohnya:

int age = 21;

Di sini kita menuliskan tipe secara langsung.

Tetapi kita juga bisa:

var age = 21;

Kita tidak menulis int, tetapi Dart tetap mengetahui bahwa:

age → int

Jadi:

Type wajib ada, tetapi penulisan type secara eksplisit tidak selalu wajib.

2. Type Annotation

Cara pertama adalah menuliskan tipe secara eksplisit.

Contoh:

int age = 21;
double price = 10.5;
String name = "Budi";
bool isStudent = true;

Ini disebut type annotation.

Strukturnya:

int       age       =       21
│         │         │       │
│         │         │       └── value
│         │         └────────── assignment
│         └──────────────────── variable name
└────────────────────────────── type

Kita secara langsung mengatakan kepada Dart:

age       → int
price     → double
name      → String
isStudent → bool

3. Bagaimana dengan var?

Sekarang kita tulis:

var age = 21;

Kita tidak menulis:

int age = 21;

Tetapi Dart tidak bingung.

Dart melihat:

21
↓
int

Kemudian Dart menyimpulkan:

age → int

Proses inilah yang disebut:

Type Inference

Type inference adalah kemampuan Dart untuk menentukan tipe data berdasarkan value yang diberikan.

4. Analogi Type Inference

Bayangkan kamu memberikan sebuah kotak kepada Dart.

Kamu bilang:

var box = 100;

Dart melihat isi kotak:

┌──────────────┐
│     100      │
└──────────────┘

Dart mengenali:

100 → int

Kemudian Dart memberi informasi:

box → int

Jadi kamu tidak perlu mengatakan:

int box = 100;

Dart bisa menyimpulkannya sendiri.

5. Contoh Type Inference

Perhatikan:

var age = 21;
var price = 10.5;
var name = "Budi";
var isStudent = true;

Dart akan melakukan:

21
↓
int

10.5
↓
double

"Budi"
↓
String

true
↓
bool

Hasil akhirnya:

age        → int
price      → double
name       → String
isStudent  → bool

Kita juga bisa menggunakan:

print(age.runtimeType);
print(price.runtimeType);
print(name.runtimeType);
print(isStudent.runtimeType);

Hasilnya kira-kira:

int
double
String
bool

6. Apa itu runtimeType?

runtimeType digunakan untuk mengetahui tipe object/value ketika program berjalan.

Contoh:

var age = 21;

print(age.runtimeType);

Output:

int

Contoh:

var name = "Budi";

print(name.runtimeType);

Output:

String

Jadi:

variable.runtimeType
       ↓
menunjukkan tipe object saat runtime

7. Type Inference pada List

Contoh yang ada di video:

var items = [10, 20, 30];

Dart dapat menyimpulkan bahwa items adalah list yang berisi integer.

Secara konsep:

items
  ↓
List<int>
  ↓
[10, 20, 30]

Kalau kita cek:

print(items.runtimeType);

hasilnya akan menunjukkan tipe list yang sesuai.

Kita juga bisa menuliskan tipe secara eksplisit:

List<int> items = [10, 20, 30];

atau menggunakan inference:

var items = [10, 20, 30];

Keduanya sama-sama memberikan informasi tipe kepada Dart.

8. Jadi var Bukan Berarti “Tanpa Type”

Ini sangat penting.

Jangan berpikir:

var age = 21;

berarti:

“age tidak punya tipe.”

❌ Salah.

Yang benar:

var age = 21
     ↓
Dart melakukan type inference
     ↓
age → int

Jadi var hanya membuat kita tidak perlu menuliskan tipe secara eksplisit.

9. Bagaimana Kalau var Tidak Diberi Nilai?

Nah, bagian ini perlu diluruskan dari video.

Misalnya:

var x;

Video menyebut bahwa runtime type-nya bisa Null.

Tetapi ada nuansa penting.

Untuk local variable seperti ini:

var x;

Dart tidak langsung menganggap variable tersebut sebagai int, String, atau tipe tertentu karena tidak ada value yang bisa digunakan untuk inference.

Dalam praktik Dart modern, kita perlu membedakan antara:

var x;

dan:

var x = null;

Yang kedua secara jelas memiliki value null.

10. null dan Null Itu Berbeda

Ini juga bagian yang sangat penting.

null — huruf kecil

null adalah nilai yang berarti:

“Tidak ada object/value.”

Contoh:

String? name = null;

Artinya name saat ini tidak mempunyai value String.

Null — huruf besar

Null adalah tipe.

Jadi:

null
↓
value

Null
↓
type

Analogi:

"Hello" → value
String  → type

Sama seperti:

null → value
Null → type

11. Kenapa Ada String?

Nanti kamu akan sering melihat:

String? name;

Tanda ? berarti variable tersebut boleh memiliki value:

String

atau:

null

Jadi:

String? name = "Budi";

boleh.

Kemudian:

name = null;

juga boleh.

Sedangkan:

String name = "Budi";

tidak boleh diberi null dalam null-safe Dart.

Ini berkaitan dengan null safety, yang akan menjadi topik penting ketika belajar Dart lebih lanjut.

12. Sekarang: Apa Itu Type Safety?

Setelah memahami type inference, kita masuk ke konsep kedua:

Type Safety

Type safety berarti sistem tipe Dart berusaha memastikan bahwa kita menggunakan value sesuai dengan tipe yang seharusnya.

Misalnya:

int age = 20;

Berarti:

age → int

Kemudian:

age = 25;

✅ Benar.

Karena:

25 → int

Tetapi:

age = "Budi";

❌ Salah.

Karena:

age → int

"Budi" → String

Tipe tidak cocok.

13. Contoh Type Safety

Misalnya:

int age = 20;

age = 30;       // ✅
age = 10;       // ✅
age = 10.5;     // ❌
age = "Budi";   // ❌

Kenapa?

Karena age sudah didefinisikan sebagai:

int

Maka value yang dimasukkan harus sesuai dengan aturan tipe tersebut.

14. Type Safety Tidak Hanya Saat Assignment

Type safety juga berlaku ketika kita melakukan operasi.

Misalnya:

var x = 10;

Dart tahu:

x → int

Kemudian:

x.toUpperCase();

❌ Bermasalah.

Kenapa?

Karena toUpperCase() adalah method yang digunakan pada String.

Sedangkan:

x → int

Jadi Dart dapat mendeteksi bahwa operasi tersebut tidak cocok.

15. Dua Level Pemeriksaan Type

Menurut video, type safety di Dart bekerja melalui dua mekanisme utama:

1. Static type checking
2. Runtime type checking

Mari kita bedakan.

16. Static Type Checking

Static type checking adalah pemeriksaan tipe yang dilakukan sebelum program benar-benar berjalan.

Dart memiliki static analyzer yang memeriksa kode kita.

Contoh:

var x = 10;

x = "Hello";

Dart mengetahui:

x → int

Tetapi kita mencoba:

String → x

Dart bisa mendeteksi masalah tersebut sebelum program berjalan.

Secara sederhana:

Source code
    ↓
Dart analyzer
    ↓
cek tipe
    ↓
❌ ditemukan masalah

Ini sangat berguna karena error bisa ditemukan lebih awal.

17. Contoh Static Checking

Misalnya:

var x = 10;

print(x.toUpperCase());

Dart mengetahui:

x → int

Lalu Dart melihat:

x.toUpperCase()

toUpperCase() bukan method yang tersedia untuk int.

Maka analyzer dapat memberi tahu:

Error

sebelum program berjalan.

18. Runtime Type Checking

Sekarang ada kondisi yang baru bisa diketahui ketika program berjalan.

Misalnya kita melakukan type casting.

Contoh sederhana:

dynamic value = "Hello";

var number = value as int;

Saat runtime Dart menemukan:

value sebenarnya → String

tetapi kita meminta:

String → int

Itu tidak cocok.

Akibatnya:

Runtime exception

Jadi:

Program dijalankan
       ↓
runtime system memeriksa
       ↓
ternyata tipe tidak cocok
       ↓
Runtime exception

19. Static vs Runtime

Sekarang bandingkan.

Static checking

int age = 20;

age = "Hello";

Dart sudah mengetahui masalahnya lebih awal.

compile/static analysis
        ↓
❌ error

Runtime checking

dynamic value = "Hello";

var number = value as int;

Informasi aktual yang diperlukan untuk memastikan cast tersebut baru bermasalah saat program berjalan.

program running
       ↓
runtime check
       ↓
❌ exception

20. Hubungannya dengan dynamic

Ini menghubungkan materi video sebelumnya dengan video sekarang.

Perhatikan:

var x = 10;

Dart mengetahui:

x → int

Sehingga:

x.toUpperCase();

dapat ditolak oleh static analyzer.

Sedangkan:

dynamic x = 10;

informasi static tentang operasi yang boleh dilakukan pada x jauh lebih terbatas.

Maka:

x.toUpperCase();

bisa lolos static analysis, tetapi ketika runtime ternyata:

x = 10

dan int tidak memiliki toUpperCase(), maka terjadi exception.

21. Kenapa Static Checking Sangat Berguna?

Bayangkan kita sedang membuat aplikasi Flutter besar.

Ada ribuan baris kode:

Project Flutter
│
├── login
├── register
├── home
├── profile
├── payment
├── settings
└── ...

Kalau semua menggunakan tipe dinamis, banyak kesalahan baru diketahui ketika aplikasi dijalankan.

Ini menyulitkan.

Dengan static typing:

kode
 ↓
static analyzer
 ↓
menemukan banyak kesalahan lebih awal
 ↓
developer memperbaiki
 ↓
baru menjalankan aplikasi

Ini membuat development lebih aman.

22. Sound Type System

Sekarang kita sampai pada istilah terakhir dari video:

Sound Typing / Sound Type System

Secara sederhana, sound type system berarti sistem tipe Dart dirancang agar informasi tipe yang digunakan oleh program tetap konsisten dengan aturan type system, dengan dukungan static checking dan runtime checking ketika diperlukan.

Dalam penjelasan pemula, kamu bisa mengingatnya sebagai:

Type Safety
     │
     ├── Static checking
     │
     └── Runtime checking
             ↓
      Sound type system

Tetapi jangan menganggap:

“Sound berarti tidak mungkin ada error.”

❌ Bukan begitu.

Program tetap bisa mengalami error.

Maksudnya adalah sistem tipe Dart memberikan jaminan tipe yang kuat dalam kondisi yang ditangani oleh sistem tipe tersebut.

23. Analogi Satpam

Bayangkan sebuah gedung.

Ada dua satpam.

Satpam pertama: Static Analyzer

Dia memeriksa kamu sebelum masuk.

"ID kamu apa?"
"Ruangan yang dituju apa?"
"Apakah kamu boleh masuk?"

Kalau salah:

❌ Tidak boleh masuk

Ini seperti static checking.

Satpam kedua: Runtime

Setelah kamu masuk gedung, masih ada pemeriksaan di dalam.

Misalnya kamu mencoba masuk ke ruangan yang sebenarnya tidak boleh kamu masuki.

Runtime check
      ↓
"Maaf, kamu tidak boleh masuk."
      ↓
Exception

Jadi ada pemeriksaan:

SEBELUM PROGRAM BERJALAN
        ↓
Static checking

SAAT PROGRAM BERJALAN
        ↓
Runtime checking

24. Gambaran Keseluruhan

Sekarang semua konsep dari video bisa kita satukan:

                    DART
                      │
                      ▼
                 TYPE SYSTEM
                      │
          ┌───────────┴───────────┐
          │                       │
          ▼                       ▼
   Type Inference             Type Safety
          │                       │
          │                ┌──────┴──────┐
          │                │             │
          ▼                ▼             ▼
     var x = 10       Static Check   Runtime Check
          │                │             │
          ▼                ▼             ▼
       x → int         sebelum run    saat program run

25. Contoh Lengkap

Mari kita buat contoh yang menggabungkan semuanya.

void main() {
  var age = 20;
  var name = "Budi";
  var price = 10.5;

  print(age.runtimeType);
  print(name.runtimeType);
  print(price.runtimeType);
}

Type inference menghasilkan:

age   → int
name  → String
price → double

Sehingga output runtimeType kira-kira:

int
String
double

26. Type Safety pada Contoh Tersebut

Karena:

var age = 20;

maka:

age → int

Ini valid:

age = 30;

Tetapi:

age = "Budi";

❌ Tidak valid.

Karena:

age → int

"Budi" → String

27. var Membantu Dart Menjaga Tipe

Perhatikan:

var age = 20;

Kemudian:

age = 21;

Diperbolehkan.

Tetapi:

age = "twenty";

ditolak.

Jadi meskipun kita tidak menulis:

int age = 20;

Dart tetap memiliki informasi:

age → int

Inilah salah satu keuntungan type inference + static typing.

28. Bagaimana dengan dynamic?

Misalnya:

dynamic value = 10;

value = "Hello";
value = true;
value = 10.5;

Ini diperbolehkan karena variable tersebut bersifat dynamic.

Tetapi konsekuensinya:

dynamic
   ↓
lebih fleksibel
   ↓
lebih sedikit informasi tipe saat static analysis
   ↓
lebih banyak potensi masalah baru diketahui saat runtime

Itulah alasan penggunaan dynamic sebaiknya tidak sembarangan.

29. Satu Koreksi Penting dari Transkrip

Ada bagian video yang mengatakan:

“var atau dynamic tanpa memperhatikan tipe akan menggunakan type inference.”

Ini perlu diperbaiki.

var memang menggunakan type inference.

Tetapi dynamic berbeda.

Contoh:

var x = 10;

Dart melakukan:

10 → int
x → int

Sedangkan:

dynamic x = 10;

kita secara eksplisit mengatakan:

x → dynamic

Walaupun value yang sedang dipegang saat itu adalah int.

Jadi:

var
→ type inference

dynamic
→ dynamic type

Jangan mencampurkan dua konsep ini.

30. Cara Mengingat Semua Materi

Gunakan alur berikut:

              VALUE
                │
                ▼
        ┌───────────────┐
        │  var x = 10   │
        └───────────────┘
                │
                ▼
        TYPE INFERENCE
                │
                ▼
             x → int
                │
                ▼
        STATIC CHECKING
                │
          ┌─────┴─────┐
          │           │
       valid       invalid
          │           │
          ▼           ▼
       lanjut       error

Untuk dynamic:

dynamic x = 10
       │
       ▼
x bersifat dynamic
       │
       ▼
static checking lebih longgar
       │
       ▼
operasi tertentu bisa lolos
       │
       ▼
runtime
       │
       ▼
dicek dengan keadaan sebenarnya
       │
       ▼
bisa terjadi exception

31. Ringkasan Perbedaan Istilah

32. Yang Paling Wajib Kamu Ingat

Kalau video ini terasa banyak istilah, cukup kuasai 5 hal ini dulu:

① Semua variable/value di Dart punya tipe

var age = 20;

tetap:

age → int

② var menggunakan type inference

var age = 20;

Dart sendiri yang mengetahui:

20 → int

③ Type safety mencegah tipe yang salah

int age = 20;

age = "Budi"; // ❌

④ Static checking menemukan banyak error lebih awal

var age = 20;

age.toUpperCase(); // ❌

Dart tahu age adalah int.

⑤ Runtime checking tetap diperlukan

Ada beberapa hal yang baru bisa dipastikan ketika program berjalan, misalnya operasi yang melibatkan nilai dinamis atau type casting.

dynamic value = "Hello";

var number = value as int; // runtime error

🧠 Kalimat kunci untuk dihafalkan

Dart adalah bahasa yang strongly typed: setiap value memiliki tipe. Kita tidak selalu harus menuliskan tipe karena Dart dapat menggunakan type inference, terutama dengan var. Type safety kemudian dibantu oleh static checking dan runtime checking.

Dan hubungan dengan materi sebelumnya:

var
↓
Dart infer tipe
↓
tipe menjadi spesifik
↓
static checking lebih kuat
↓
lebih aman

sedangkan:

dynamic
↓
tipe lebih fleksibel
↓
static checking lebih longgar
↓
sebagian masalah bisa baru muncul saat runtime

Kalau kamu memahami alur var → type inference → static type checking → type safety, maka fondasi sistem tipe Dart kamu sudah mulai kuat.