Overview #

Dart adalah bahasa pemrograman modern yang dikembangkan Google, dirancang khusus untuk membangun aplikasi client-side yang cepat, aman, dan dapat berjalan di mana saja — dari mobile dan desktop hingga web dan server. Dart bukan hanya “bahasa untuk Flutter” — ia adalah bahasa yang berdiri sendiri dengan ekosistem dan tooling yang matang.

Filosofi Desain Dart #

Dart dirancang dengan empat prinsip utama yang menjadi panduan setiap keputusan desain bahasanya:

+--------------------------------------------------+
|                Prinsip Dart                      |
|                                                  |
|  1. UI-Optimized    Bahasa dirancang untuk       |
|                     kebutuhan spesifik UI:       |
|                     async, event-driven,         |
|                     hot reload                   |
|                                                  |
|  2. Productive      Familiar bagi developer      |
|                     yang sudah tahu Java/JS/C#,  |
|                     tooling lengkap built-in     |
|                                                  |
|  3. Fast            AOT ke machine code native,  |
|                     JIT untuk development,       |
|                     startup instan di produksi   |
|                                                  |
|  4. Portable        Compile ke ARM/x64/RISC-V,   |
|                     JavaScript, WebAssembly      |
+--------------------------------------------------+

Dart Bukan Hanya untuk Flutter #

Meski paling dikenal sebagai bahasa Flutter, Dart bisa digunakan secara independen untuk berbagai keperluan:

# Jalankan Dart tanpa Flutter (standalone)
dart run my_script.dart

# Compile ke executable native (tidak perlu VM)
dart compile exe bin/server.dart -o server
./server   # berjalan langsung, tanpa Dart VM

# Compile ke JavaScript
dart compile js web/main.dart -o web/main.js

Karakteristik Utama Dart #

Strongly Typed dengan Type Inference #

Dart adalah bahasa strongly typed — setiap nilai memiliki tipe yang jelas dan diverifikasi oleh compiler. Namun Dart juga mendukung type inference sehingga kamu tidak selalu perlu menulis tipe secara eksplisit:

// Explicit type — selalu valid
String nama = 'Flutter';
int tahun = 2025;

// Type inference dengan var — compiler menyimpulkan tipenya
var kota = 'Jakarta';     // disimpulkan sebagai String
var versi = 3.27;         // disimpulkan sebagai double
var aktif = true;         // disimpulkan sebagai bool

// dynamic — menonaktifkan type checking (hindari sebisa mungkin)
dynamic apapun = 'teks';
apapun = 42;              // valid, tapi kehilangan type safety

Sound Null Safety #

Dart memiliki sound null safety bawaan. Ini berarti nilai tidak bisa bernilai null kecuali kamu menyatakannya bisa. Dengan sound null safety, Dart melindungi kamu dari null exception saat runtime melalui analisis kode statis. Tidak seperti bahasa null-safe lainnya, ketika Dart menentukan bahwa sebuah variabel non-nullable, variabel tersebut tidak pernah bisa null.

// Non-nullable (default) — compiler menjamin tidak pernah null
String nama = 'Budi';
// nama = null;  // ERROR compile time!

// Nullable — tambahkan ? untuk mengizinkan null
String? judul = null;     // OK

// Sound berarti: jaminan ini berlaku hingga runtime
// Bukan hanya static analysis yang bisa "dibohongi"

Dengan 100% null safety di Dart, kita memiliki sound type system. Kamu bisa percaya bahwa jika sebuah tipe mengatakan nilai tidak null, maka ia tidak pernah bisa null. Ini menghindari kelas error tertentu seperti null pointer exception, dan juga memungkinkan compiler dan runtime mengoptimalkan kode dengan cara yang tidak bisa dilakukan tanpa null safety.

Object-Oriented Sekaligus Functional #

Dart adalah bahasa multi-paradigma yang mendukung OOP dan functional programming secara bersamaan:

// OOP: class, inheritance, mixin
class Animal {
  final String name;
  Animal(this.name);
  void speak() => print('...');
}

class Dog extends Animal {
  Dog(super.name);
  @override
  void speak() => print('$name: Guk!');
}

// Functional: fungsi sebagai first-class citizen
final double Function(double) square = (x) => x * x;
final numbers = [1, 2, 3, 4, 5];
final squares = numbers.map(square).toList();
// [1.0, 4.0, 9.0, 16.0, 25.0]

// Functional: immutability dengan final dan const
final List<String> tags = ['flutter', 'dart'];
const Map<String, int> scores = {'a': 1, 'b': 2};

Target Platform Dart #

Dart dapat dikompilasi ke berbagai target platform dengan toolchain yang berbeda:

SOURCE CODE DART
       |
       +-------> Native Platform
       |           dart compile exe  --> standalone executable
       |           gen_snapshot AOT  --> Flutter release build
       |           gen_snapshot JIT  --> Flutter debug build
       |           Target: ARM64, x64, RISC-V
       |
       +-------> Web Platform
       |           dart2js      --> JavaScript (optimized)
       |           dartdevc     --> JavaScript (modular, dev)
       |           dart2wasm    --> WebAssembly (stable di Dart 3.3+)
       |
       +-------> Server/CLI
                   dart run     --> JIT execution (scripting)
                   dart compile --> native binary

Multi-Architecture Support #

# Build untuk arsitektur berbeda
flutter build apk --target-platform android-arm64   # ARM 64-bit
flutter build apk --target-platform android-arm     # ARM 32-bit
flutter build apk --target-platform android-x64     # x86 64-bit

# Dart juga mendukung RISC-V (baru di Dart 3.x)
# untuk perangkat embedded dan server RISC-V

Ekosistem Tooling Dart #

Salah satu kekuatan Dart adalah tooling yang sangat lengkap — semuanya tersedia dalam satu CLI:

Dart CLI #

# Menjalankan program
dart run lib/main.dart

# Package management
dart pub get              # install dependencies
dart pub add http         # tambah package
dart pub upgrade          # update semua package

# Analisis kode
dart analyze              # static analysis
dart fix --apply          # auto-fix issues

# Formatting
dart format lib/          # format seluruh direktori

# Testing
dart test                 # jalankan semua test

# Compile
dart compile exe          # native executable
dart compile js           # JavaScript
dart compile wasm         # WebAssembly
dart compile aot-snapshot # AOT snapshot

# Dokumentasi
dart doc                  # generate API docs

pub.dev — Package Repository #

pub.dev adalah repository package Dart dan Flutter resmi. Beberapa statistik per 2025:

Total package di pub.dev:    > 50.000 package
Package dengan null safety:  > 99% dari top 1000
Package dengan Flutter SDK:  > 30.000 package
Package dengan Dart SDK:     > 20.000 package (server, CLI, web)

Setiap package dinilai menggunakan pub points — sistem penilaian otomatis yang mengukur:

• Mengikuti konvensi Dart (pub points: 10)
• Dokumentasi lengkap (pub points: 20)
• Platform support (pub points: 20)
• Null safety (pub points: 50)
• Dependency yang up-to-date (pub points: 10)

Dart SDK — Batteries Included #

Dart menyertakan library standar yang sangat lengkap:

import 'dart:convert';
import 'dart:io';
import 'dart:async';

// dart:io -- HTTP request
Future<void> fetchData() async {
  final client = HttpClient();
  final request = await client.getUrl(
    Uri.parse('https://api.example.com/data'),
  );
  final response = await request.close();
  final body = await response.transform(utf8.decoder).join();
  final data = jsonDecode(body);
  print(data);
  client.close();
}

// dart:convert -- JSON
final jsonString = '{"nama": "Flutter", "versi": 3}';
final map = jsonDecode(jsonString) as Map<String, dynamic>;
final backToJson = jsonEncode(map);

Dart vs Bahasa Lain: Posisi di Ekosistem #

Dart bukan pengganti JavaScript -- ia adalah alternatif yang lebih
type-safe untuk UI development yang dikompilasi ke JS atau Wasm.

Dart vs JavaScript/TypeScript:
  [+] Sound type system (bukan structural typing yang bisa "dibohongi")
  [+] AOT compilation ke native machine code
  [+] Isolate concurrency (lebih aman dari Web Workers)
  [-] Ekosistem npm jauh lebih besar
  [-] Lebih sedikit developer di pasar kerja

Dart vs Kotlin:
  [+] Berjalan di lebih banyak platform (web, embedded)
  [+] Hot Reload tanpa plugin tambahan
  [+] Lebih ringan untuk UI development
  [-] Kotlin lebih matang untuk backend JVM
  [-] Ekosistem Android library lebih kaya di Kotlin

Dart vs Swift:
  [+] Cross-platform (tidak terikat Apple ecosystem)
  [+] Sintaks lebih konsisten dan predictable
  [-] Swift lebih optimal untuk iOS-specific development
  [-] Interop dengan Objective-C lebih baik di Swift

Dart Sound Type System vs TypeScript #

Perbedaan paling penting yang sering diabaikan:

// TypeScript (structurally typed, TIDAK sound):
interface Animal { name: string }
interface Dog { name: string; bark(): void }

function process(a: Animal) { /* ... */ }
const dog: Dog = { name: 'Rex', bark: () => {} };
process(dog);   // OK di TypeScript -- structural compatibility

// Masalah: TypeScript bisa "dibohongi" dengan type assertion
const x = "bukan number" as unknown as number;  // TypeScript mengizinkan!

// Dart (nominally typed, SOUND):
// Tidak ada cara untuk "membohongi" type system Dart
// Jika compiler bilang non-null, maka PASTI non-null saat runtime

String nama = 'Budi';
// nama = null as String;  // Tetap ERROR -- tidak bisa di-cast
// Jaminan ini berlaku hingga runtime, bukan hanya static analysis

Soundness adalah properti yang membedakan Dart dari TypeScript. TypeScript hanya menjamin type safety secara statis — ada celah yang bisa dieksploitasi dengan as unknown as T. Dart menjamin type safety hingga runtime — compiler dan runtime bekerja bersama sehingga tidak ada celah.

Ringkasan #

• Dart adalah bahasa strongly typed, multi-paradigma yang mendukung OOP dan functional programming — dirancang khusus untuk UI client-side development.
• Sound null safety Dart bukan sekadar static analysis — jaminannya berlaku hingga runtime, tidak ada celah yang bisa dieksploitasi seperti TypeScript.
• Dart bisa dikompilasi ke ARM/x64/RISC-V (native), JavaScript (web), dan WebAssembly — satu bahasa untuk semua platform.
• Tooling Dart sangat lengkap dalam satu CLI: dart run, dart pub, dart analyze, dart format, dart test, dart compile — semua built-in.
• pub.dev memiliki lebih dari 50.000 package dengan 99% top package sudah mendukung null safety.
• Dart SDK menyertakan library standar yang kaya: dart:async, dart:io, dart:convert, dart:ffi, dart:isolate, dan lainnya — tanpa perlu library pihak ketiga untuk kebutuhan dasar.
• Dibandingkan TypeScript, Dart unggul dalam soundness type system. Dibanding Kotlin, Dart lebih portabel. Dibanding Swift, Dart lebih cross-platform.

← Sebelumnya: Perbandingan Native   Berikutnya: Null Safety →