Dart: wat is het, kenmerken van taal Flutter en programmeren

Wat is Dart?

Dart — een programmeertaal met C-achtige syntaxis, ontwikkeld door Google onder leiding van Lars Bak (maker van Eclipse). De eerste release vond plaats in 2011, maar echte populariteit kreeg Dart in 2018 met de komst van Flutter 1.0. De taal is ontworpen voor het maken van gebruikersinterfaces: het heeft ingebouwde ondersteuning voor streams, futures en reactieve patronen.

De filosofie van Dart — "balans tussen prestaties en productiviteit". De taal ondersteunt twee compilatiestrategieën: JIT (Just-In-Time) voor ontwikkeling met hot reload en AOT (Ahead-Of-Time) voor release-builds met native prestaties. De JIT-compiler injecteert gewijzigde code in milliseconden in de draaiende applicatie, zonder hercompilatie van APK — dit is het belangrijkste voordeel van Dart ten opzichte van andere talen in de context van mobiele ontwikkeling.

Het belangrijkste kenmerk van Dart — sound null safety, geïntroduceerd in Dart 2.12 (2021). Het typesysteem garandeert dat een variabele niet null kan zijn zonder expliciete aanduiding (int?). Dit elimineert NullPointerException in de compilatiefase. Volgens Google heeft de implementatie van null safety het aantal crashes in Flutter-applicaties met 30% verminderd in de productieomgeving.

Dart-ecosysteem

Het Dart-ecosysteem omvat drie hoofdrichtingen: Flutter (mobiele en desktop-applicaties), AngularDart (webapplicaties) en Dart Server (serveroplossingen). Flutter — het dominante platform: volgens Statista (2025) wordt Flutter gebruikt in 46% van de cross-platform mobiele projecten, voor op React Native (38%) en Xamarin (8%).

Dart-syntaxis: types, functies en klassen

Dart-syntaxis doet denken aan Java en JavaScript, maar heeft eigen unieke constructies. Alles in Dart is een object — zelfs int, double en bool erven van Object. Typering is optioneel: een variabele gedeclareerd als var leidt het type automatisch af, maar het wordt aanbevolen om types expliciet te specificeren voor leesbaarheid en prestaties.

Basistypes en declaraties

Dart ondersteunt int, double, String, bool, List, Set, Map, Record, Symbol en Runes. Nullable type — elk type met achtervoegsel ? (int?, String?). De ??-operator (null-aware) retourneert de waarde rechts als links null is. Cascadenotatie (..) maakt het mogelijk om meerdere methoden op hetzelfde object aan te roepen zonder de referentie te herhalen.

// Basistypes en declaraties in Dart
void main() {
  // Expliciete typering
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — variabele kan null zijn
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Null-aware operator

  // Collecties met generieken
  List<String> items = ['Dart', 'Flutter', 'Mobile'];
  Map<String, dynamic> config = {
    'version': '3.0',
    'mode': 'debug',
  };

  // Cascadenotatie
  final list = <String>[]
    ..add('one')
    ..add('two')
    ..sort();
}

// Record — anoniem onveranderlijk type
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

Het type dynamic schakelt typecontrole uit — gebruik het alleen bij het werken met JSON of dynamische gegevens. Record — nieuw type in Dart 3.0, waarmee waarden gegroepeerd kunnen worden zonder een aparte klasse te maken. De null-aware operator ?? — standaard manier om met nullable waarden te werken, ter vervanging van lange if-else controles.

Klassen en mixins

Klassen in Dart — enkele overerving (extends), meervoudig via mixins (mixin). Dart ondersteunt interfaces niet als apart concept — elke klasse kan worden geïmplementeerd (implements). Mixin — een klasse zonder constructor, waarvan methoden en velden aan elke klasse kunnen worden toegevoegd via het sleutelwoord with.

// Klassen, overerving en mixins in Dart
abstract class Animal {
  void sound(); // abstracte methode
}

mixin Swimmer {
  void swim() => print('Swimming...');
}

mixin Flyer {
  void fly() => print('Flying...');
}

class Duck extends Animal with Swimmer, Flyer {
  @override
  void sound() => print('Quack!');
}

void main() {
  final duck = Duck();
  duck.sound(); // Quack!
  duck.swim();  // Swimming...
  duck.fly();   // Flying...
}

// Genoemde constructor
class Config {
  final String env;

  Config.development() : env = 'dev';
  Config.production()  : env = 'prod';
}

Klasse Duck erft van Animal en gebruikt twee mixins — Swimmer en Flyer. Dit demonstreert meervoudige overerving zonder problemen van de ruitstructuur: mixins worden lineair opgelost (super chain). Genoemde constructors (Config.development) — alternatief voor statische fabrieksmethoden om objecten te maken met vooraf ingestelde parameters.

Asynchroon programmeren in Dart: Future, Stream en async/await

Asynchroon programmeren in Dart wordt gerealiseerd via Future (enkele waarde), Stream (reeks waarden) en async/await. Dart gebruikt een single-thread event loop-model, vergelijkbaar met JavaScript, maar met een belangrijk verschil: langdurige berekeningen blokkeren de UI niet, omdat Dart-code wordt uitgevoerd in Isolate — een aparte thread zonder gedeeld geheugen.

Future vertegenwoordigt een asynchrone bewerking die na enige tijd wordt voltooid. Future kan in de status pending (wachten), completed with value (succes) of completed with error (fout) zijn. De keten .then().catchError() — alternatief voor async/await, maar het wordt aanbevolen om await te gebruiken voor leesbaarheid.

// Asynchroon laden van gegevens met Future en Stream
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future voor enkele aanvraag
  Future<Map<String, dynamic>> fetchUser(int id) async {
    final response = await http.get(
      Uri.parse('$baseUrl/users/$id'),
    );

    if (response.statusCode == 200) {
      return jsonDecode(response.body);
    } else {
      throw Exception('Failed to load user: ${response.statusCode}');
    }
  }

  // Stream voor gegevensreeks
  Stream<int> countStream(int max) async* {
    for (var i = 1; i <= max; i++) {
      await Future.delayed(Duration(seconds: 1));
      yield i;
    }
  }
}

void main() async {
  final api = ApiService('https://api.example.com');

  // Gebruik van await
  final user = await api.fetchUser(1);
  print('User: ${user['name']}');

  // Stream verwerken met await for
  await for (final count in api.countStream(5)) {
    print('Count: $count');
  }
}

Klasse ApiService demonstreert twee soorten asynchroon programmeren: Future voor een HTTP-verzoek (één antwoord) en Stream voor een sequentiële teller (generator met async* en yield). Stream is efficiënt voor het werken met sensoren, geolocatie, Firebase Realtime Database — overal waar gegevens continu binnenkomen. Isolate gebruikt apart geheugen — gegevens worden verzonden via SendPort/ReceivePort.

Dart en Flutter: applicatiearchitectuur

Dart en Flutter vormen één stack: Flutter — UI-framework, Dart — taal voor UI-beschrijving. In Flutter is alles een widget (Widget) — van een knop tot de hele applicatie. Widgets kunnen stateful (met veranderlijke toestand) en stateless (onveranderlijk) zijn. Dart beschrijft declaratieve UI: build() retourneert een widgetboom die Flutter rendert met Skia (of Impeller op iOS).

Structuur van een Flutter-applicatie

Een Flutter-applicatie in Dart bestaat uit main() → runApp(MyApp()) → MaterialApp. MaterialApp bevat routering (routes), thema (theme) en lokalisatie. Elk scherm is een Scaffold, met AppBar, Body (meestal Column/ListView) en BottomNavigationBar. Navigatie via Navigator.push/pop of benoemde routes.

// Eenvoudige Flutter-applicatie in Dart
import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Dart Demo',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: HomeScreen(),
    );
  }
}

class HomeScreen extends StatefulWidget {
  @override
  _HomeScreenState createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {
  int _counter = 0;

  void _increment() {
    setState(() {
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Dart + Flutter')),
      body: Center(
        child: Text('Counter: $_counter'),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _increment,
        child: Icon(Icons.add),
      ),
    );
  }
}

Widget HomeScreen — StatefulWidget met interne toestand _counter. Aanroep van setState() meldt Flutter dat de UI opnieuw moet worden opgebouwd — Dart-code herstart build(), waardoor een nieuwe widgetboom ontstaat. Flutter vergelijkt efficiënt (diff) de oude en nieuwe boom, waarbij alleen de gewijzigde delen van het scherm worden bijgewerkt. Hot Reload vervangt build() zonder de toestand _counter te resetten.

Dart-compilatie: JIT vs AOT

Dart-compilatie — hybride: JIT voor ontwikkeling en AOT voor productie. In debug-modus start Dart VM de JIT-compiler, die bytecode interpreteert met de mogelijkheid van hot code-vervanging. In release maakt dart compile exe of flutter build een native AOT-binair bestand voor een specifieke architectuur (arm64, x86_64, armv7).

JIT-compilatie van Dart in debug-modus zorgt voor hot reload in ~1 seconde — de ontwikkelaar ziet UI-wijzigingen zonder verlies van applicatiestatus. AOT-compilatie levert prestaties die vergelijkbaar zijn met native Swift/Kotlin-applicaties. Volgens Google haalt Flutter op Dart AOT 60 FPS-animaties, zelfs op middensegment apparaten.

Tools voor de Dart-ontwikkelaar

Tools voor de Dart-ontwikkelaar omvatten Dart SDK (compiler dart, dartanalyzer, dartfmt, pub), Flutter SDK en IDE-plugins. Dart SDK wordt samen met Flutter SDK geïnstalleerd in de map flutter/bin/cache/dart-sdk. Pub — pakketbeheerder, leest pubspec.yaml en downloadt afhankelijkheden van pub.dev.

Belangrijkste tools

dart analyze — statische analysator die types, ongebruikte imports en potentiële fouten controleert. dart format — formatter die code automatisch in een uniforme stijl brengt. dart doc — documentatiegenerator uit ///-commentaren. Flutter DevTools — profiler met weergave van widgetboom, logs, geheugen en netwerk. Dart VM Service — debuggen van een draaiende applicatie via WebSocket.

# pubspec.yaml — configuratie van een Dart-project
name: my_flutter_app
description: A new Flutter project.
version: 1.0.0

environment:
  sdk: '>=3.0.0 <4.0.0'

dependencies:
  flutter:
    sdk: flutter
  http: ^1.2.0
  provider: ^6.1.0
  shared_preferences: ^2.2.0
  json_annotation: ^4.8.0

dev_dependencies:
  flutter_test:
    sdk: flutter
  build_runner: ^2.4.0
  json_serializable: ^6.7.0
  flutter_lints: ^3.0.0

Het bestand pubspec.yaml beschrijft de afhankelijkheden van een Dart-project. Het veld environment:sdk specificeert de Dart-versie — huidige stabiel 3.x. Dependencies — belangrijkste bibliotheken, dev_dependencies — voor testen en codegeneratie. json_annotation + json_serializable genereren code voor JSON-serialisatie via build_runner. flutter_lints — set regels voor de analysator.