Dart

Definition: Google’s language optimized for UI-centric app development, best known as the language behind Flutter and its single-codebase app model.

Paradigm: OOP | Typing: Static (with inference)

Pros

Hot reload and hot restart make UI iteration fast during Flutter development.
The same language can target mobile, web, and desktop through Flutter.
Sound null safety improves state modeling and reduces many runtime crashes.
AOT compilation gives release builds a native feel on mobile devices.
The framework and language are aligned, which keeps the ecosystem coherent.

Cons

Outside Flutter, the ecosystem is thinner than JavaScript, Kotlin, or Swift.
Deep widget trees and rebuild patterns require architectural discipline.
Web output can be less idiomatic than purpose-built frontend stacks.
Hiring is narrower than for mainstream mobile or web languages.

Best For

Cross-platform app UI where shared design systems and business logic matter.
Teams that want one language across iOS, Android, web, and desktop.

Real Examples

Google Ads and other Google-facing experiences use Flutter/Dart in parts of the stack.
Alibaba’s Xianyu app is one of the best-known large Flutter deployments.
Many startups choose Flutter for a shared mobile UI layer and smaller team size.

Use Cases

Mobile shells, reusable UI components, and shared application logic.
Desktop utilities and prototypes built on Flutter.
Example:

class User {
	final String id;
	final bool active;
	User(this.id, this.active);
}

Extended Syntax & Features

Dart syntax feels familiar to developers who have experience with C-like languages, Java, JavaScript, or C#. It offers modern conveniences like type inference, async/await, and a robust object-oriented structure.

Basic Data Types and Type Inference

Dart is statically typed but supports type inference using the var keyword. Explicit types can also be provided when you want to make your code more self-documenting or when the compiler cannot determine the type.

int and double for numerical representations.
String for textual data (supports robust string interpolation with $variable or ${expression}).
bool for true/false boolean values.
List, Set, and Map for versatile data collections.

// Type inference
var name = 'Dart'; // Inferred as String
var year = 2011;   // Inferred as int
var pi = 3.14;     // Inferred as double

// Explicit typing
String title = 'Flutter Dev';
int version = 3;
bool isAwesome = true;

// Collections
List<String> fruits = ['Apple', 'Banana', 'Cherry'];
Set<int> uniqueNumbers = {1, 2, 3, 3, 4}; // Results in {1, 2, 3, 4}
Map<String, int> ages = {'Alice': 30, 'Bob': 25};

// String interpolation
print('Language: $name, Version: $version');
print('Next version: ${version + 1}');

Control Flow

Dart supports standard control flow mechanisms such as if-else, for, while, do-while, and switch-case. In Dart 3, exhaustive pattern matching was introduced for switch statements and expressions, drastically improving the language’s safety.

// If-else
if (year >= 2000) {
  print('21st century');
} else {
  print('20th century');
}

// Standard For loop
for (var i = 0; i < 5; i++) {
  print(i);
}

// For-in loop for iterable collections
for (var fruit in fruits) {
  print(fruit);
}

// Pattern matching in Switch (Dart 3+)
var shape = 'Circle';
switch (shape) {
  case 'Square' || 'Rectangle':
    print('It has 4 sides');
  case 'Circle':
    print('It is round');
  default:
    print('Unknown shape');
}

// Switch expression (Dart 3+)
String description = switch (version) {
  1 => 'First Release',
  2 => 'Sound Null Safety',
  3 => 'Records & Patterns',
  _ => 'Unknown'
};
print(description);

Functions and Methods

Functions in Dart are first-class objects. Dart supports named and positional parameters, both optional and required. This makes API design highly flexible and clear.

// Basic function with positional required parameters
int add(int a, int b) {
  return a + b;
}

// Arrow function syntax for single-expression functions
int multiply(int a, int b) => a * b;

// Optional positional parameters (enclosed in square brackets)
String greet(String name, [String? title]) {
  if (title != null) {
    return 'Hello $title $name';
  }
  return 'Hello $name';
}

// Named parameters (enclosed in curly braces) 
// Usually optional by default, but can be marked required
void printProfile({required String name, int age = 0}) {
  print('Name: $name, Age: $age');
}

// Calling functions
greet('Alice', 'Dr.'); // Output: Hello Dr. Alice
greet('Bob');          // Output: Hello Bob
printProfile(name: 'Charlie', age: 25);

Null Safety

Dart uses Sound Null Safety, meaning values cannot be null unless you explicitly allow them to be. This eliminates the possibility of null reference exceptions at runtime, improving the security and stability of the application.

int a = 1; // Cannot be null, compiler ensures it
int? b;    // Can be null, automatically initialized to null

// Using the null-aware operator
int result = b ?? 0; // If b is null, use 0 instead

// Null-aware assignment
b ??= 5; // Assign 5 to b only if b is currently null

// Null-aware method invocation
int? length = b?.bitLength; // Returns bitLength if b is not null, otherwise returns null

Classes and Object-Oriented Programming

Dart is purely object-oriented. Every value is an object (even numbers and null), and every object is an instance of a class (ultimately inheriting from Object).

import 'dart:math';

class Point {
  // Instance variables
  double x;
  double y;

  // Syntactic sugar constructor: immediately assigns to instance variables
  Point(this.x, this.y);

  // Named constructor: allows alternative ways to instantiate a class
  Point.origin() : x = 0, y = 0;

  // Method
  double distanceTo(Point other) {
    var dx = x - other.x;
    var dy = y - other.y;
    return sqrt(dx * dx + dy * dy); 
  }
}

// Usage
var p1 = Point(2.0, 3.0);
var p2 = Point.origin();
print('Distance: ${p1.distanceTo(p2)}');

Advanced Concepts

Concurrency and Asynchronous Programming

Dart is inherently single-threaded, utilizing an event loop to handle execution. It achieves concurrency through asynchronous programming via Future, Stream, and async/await keywords. This is vital in UI development to avoid blocking the main thread during heavy operations.

Future: Represents a potential value or error that will be available at some time in the future (akin to a Promise in JavaScript).
Stream: Represents a sequence of asynchronous events, perfect for handling streams of data over time, like WebSockets or continuous user interactions.

// Using async/await with Futures
Future<String> fetchUserData() async {
  // Simulate a network delay
  await Future.delayed(Duration(seconds: 2));
  return 'User data loaded from server';
}

void main() async {
  print('Fetching data...');
  var data = await fetchUserData(); // Execution pauses here until Future completes
  print(data);
}

Isolates

When an application encounters heavy computational tasks (like parsing a massive JSON file or complex image processing) that would block the main UI thread, Dart provides Isolates. Unlike threads in Java or C++, Isolates do not share memory and communicate solely by passing messages through ports. This eliminates the need for locks and prevents race conditions.

import 'dart:isolate';

// This function will run in a separate isolate
void heavyComputation(SendPort sendPort) {
  int result = 0;
  for (int i = 0; i < 1000000000; i++) {
    result += i;
  }
  // Send the result back to the main isolate
  sendPort.send(result);
}

void runIsolate() async {
  ReceivePort receivePort = ReceivePort();
  // Spawn the isolate and pass the send port
  await Isolate.spawn(heavyComputation, receivePort.sendPort);
  
  // Listen for messages from the isolate
  receivePort.listen((data) {
    print('Result from isolate: $data');
  });
}

Mixins

Mixins are a powerful way of reusing a class’s code in multiple, independent class hierarchies. They solve the multiple inheritance problem by providing a clean mechanism to share specific behaviors across unrelated classes without the complexities of deep inheritance chains.

mixin Logger {
  void log(String message) {
    print('${DateTime.now()}: LOG: $message');
  }
}

mixin Validatable {
  bool isValid() => true;
}

// Class using multiple mixins
class DatabaseConnection with Logger, Validatable {
  void connect() {
    if (isValid()) {
      log('Connecting to the database...');
      // actual connection logic
    }
  }
}

Extensions

Extension methods allow developers to add new functionality to existing libraries and classes (even those you do not own, like String or List) without modifying their source code or using subclassing.

extension StringExtensions on String {
  // Add a getter to String
  bool get isEmail {
    return this.contains('@') && this.contains('.');
  }
  
  // Add a method to String
  String capitalize() {
    if (this.isEmpty) return this;
    return '${this[0].toUpperCase()}${this.substring(1)}';
  }
}

void testExtensions() {
  String text = 'test@example.com';
  print(text.isEmail); // Output: true
  print('dart'.capitalize()); // Output: Dart
}

Records and Pattern Matching (Dart 3+)

Dart 3 introduced Records (anonymous, immutable aggregate structures similar to tuples) and advanced pattern matching. This shifted Dart towards more functional programming paradigms, enabling developers to return multiple values from a function easily and destructure them elegantly.

// Records can have positional and named fields
var employee = ('Alice', age: 30, department: 'Engineering');
print(employee.$1); // Access positional field: Alice
print(employee.age); // Access named field: 30

// Function returning a Record
(double, double) getLocation() {
  return (40.7128, -74.0060);
}

void destructuring() {
  // Pattern matching in variable declaration (Destructuring)
  var (lat, lng) = getLocation();
  print('Latitude: $lat, Longitude: $lng');
}

Ecosystem & Tooling

The Dart ecosystem is deeply intertwined with the Flutter framework, but Dart is fully capable of running independently for backend servers, scripting, and CLI applications.

Pub (pub.dev): The official package manager for Dart and Flutter. It hosts thousands of reusable libraries, ranging from UI components (like provider or bloc) to database drivers (sqflite), network clients (http, dio), and utility tools.
Dart SDK: The core software development kit that includes the Dart VM, compilers (AOT and JIT), and core libraries (dart:core, dart:async, dart:io, etc.).
Flutter: The dominant UI toolkit framework for Dart. It allows developers to build natively compiled, highly performant applications for mobile, web, desktop, and embedded devices from a single codebase.
Build Runner: A powerful build system for Dart that allows developers to run code generators to create boilerplate code (e.g., for JSON serialization via json_serializable or dependency injection via injectable).
Linter & Analyzer: Dart provides a very strict, robust static analyzer that helps enforce style rules, sound null safety, and performance best practices directly in your IDE (VS Code, Android Studio, IntelliJ).

Code Examples

1. Hello World and Basic CLI Scripting

A simple Dart script showing command line arguments parsing and basic I/O operations.

import 'dart:io';

// The main function is the entry point of any Dart application
void main(List<String> args) {
  if (args.isEmpty) {
    print('Hello, World!');
    stdout.write('What is your name? ');
    String? name = stdin.readLineSync();
    print('Nice to meet you, $name!');
  } else {
    print('Hello, ${args.join(" ")}!');
  }
}

2. Network Request (HTTP API Call)

Dart makes it easy to interact with RESTful HTTP APIs using the http package (or the built-in dart:io or dart:html libraries). Parsing JSON into strong-typed Dart objects is a standard practice.

import 'dart:convert';
import 'package:http/http.dart' as http; // Make sure to add http to pubspec.yaml

// Data model representing the JSON response
class Post {
  final int id;
  final String title;
  final String body;

  Post({required this.id, required this.title, required this.body});

  // Factory constructor to instantiate from JSON
  factory Post.fromJson(Map<String, dynamic> json) {
    return Post(
      id: json['id'],
      title: json['title'],
      body: json['body'],
    );
  }
}

Future<void> fetchPosts() async {
  final url = Uri.parse('https://jsonplaceholder.typicode.com/posts/1');
  
  try {
    // Await the HTTP GET request
    final response = await http.get(url);
    if (response.statusCode == 200) {
      // Decode the JSON string into a Map
      var jsonResponse = jsonDecode(response.body);
      // Create a strongly typed Post object
      var post = Post.fromJson(jsonResponse);
      print('Post Title: ${post.title}');
    } else {
      print('Failed to load post. Status: ${response.statusCode}');
    }
  } catch (e) {
    print('Error occurred during network request: $e');
  }
}

3. Asynchronous Streams and StreamControllers

Streams are essential in Dart for handling asynchronous sequences of data over time, such as real-time updates from a database, file reading, or user interface event streams in Flutter.

import 'dart:async';

// A function that yields a sequence of integers asynchronously
Stream<int> countStream(int to) async* {
  for (int i = 1; i <= to; i++) {
    await Future.delayed(Duration(milliseconds: 500));
    yield i; // yield emits a value to the stream
  }
}

void consumeStream() async {
  print('Starting stream consumption...');
  
  // Await for each value sequentially as they are emitted
  await for (var value in countStream(5)) {
    print('Received from stream: $value');
  }
  
  print('Stream finished.');
}

// Using StreamController for manual stream management
void manualStream() {
  final controller = StreamController<String>();
  
  // Listen to the stream
  controller.stream.listen(
    (data) => print('Data: $data'),
    onError: (err) => print('Error: $err'),
    onDone: () => print('Done listening.'),
  );
  
  // Add events to the stream
  controller.add('Event 1');
  controller.add('Event 2');
  controller.close();
}

4. Advanced Object-Oriented Patterns (Factory Constructors)

Factory constructors are highly useful when you do not necessarily want a new instance of a class to be created every time it is called. This is fantastic for implementing the Singleton pattern, returning cached instances, or returning subtypes.

class AppConfig {
  // Static variable holding the single instance
  static final AppConfig _instance = AppConfig._internal();
  
  String appName = 'My Dart App';
  String version = '1.0.0';
  
  // Private named constructor
  AppConfig._internal();
  
  // Factory constructor returning the singleton instance
  factory AppConfig() {
    return _instance;
  }
  
  void printConfig() {
    print('App: $appName (v$version)');
  }
}

void testSingleton() {
  var config1 = AppConfig();
  var config2 = AppConfig();
  
  // modifying config1 affects config2 because they are the same instance
  config1.version = '1.0.1';
  
  print('Are they the exact same instance? ${identical(config1, config2)}'); // Output: true
  config2.printConfig(); // Output: App: My Dart App (v1.0.1)
}

5. Collection Operations (Functional Programming Style)

Dart’s collections (List, Set, Map) support robust functional operations out of the box like map, where, reduce, fold, and any. This allows for concise and readable data manipulation.

void collectionOperations() {
  List<int> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  
  // Filter even numbers and square them, forming a new list
  var processed = numbers
      .where((n) => n % 2 == 0) // Keep even numbers: [2, 4, 6, 8, 10]
      .map((n) => n * n)        // Square them: [4, 16, 36, 64, 100]
      .toList();
      
  print('Processed list: $processed');
  
  // Reduce to sum all numbers
  var sum = numbers.reduce((value, element) => value + element);
  print('Sum of numbers: $sum');
  
  // Check if any number is greater than 8
  bool hasLargeNumbers = numbers.any((n) => n > 8);
  print('Has numbers > 8: $hasLargeNumbers');
}

Best Practices

Prefer final and const: When variables are not meant to be reassigned, always declare them as final. If they are compile-time constants (meaning their value is known completely at compile time), use const. This improves readability, state management, and allows the Dart compiler to optimize the code for significantly better performance and smaller memory footprint.
Use Meaningful Names and Adhere to Style Guides: Follow the official Dart style guide closely. Use UpperCamelCase for classes, enum types, typedefs, and type parameters. Use lowerCamelCase for variables, constants, parameters, and named constructors. Use lowercase_with_underscores for file and folder names.
Leverage Sound Null Safety Responsibly: Don’t use the bang operator (!) excessively or carelessly. It forces the compiler to treat a nullable value as non-nullable, which will crash the app (throw an exception) if the value actually turns out to be null at runtime. Instead, handle nulls gracefully using null checking (if (x != null)), null-aware operators (?., ??), or early returns.
Avoid Deeply Nested Widget Trees (Flutter): In Flutter, deeply nested widget trees can quickly become hard to read, trace, and maintain (“Callback Hell” equivalent for UI). Break down complex monolithic UIs into smaller, modular, stateless, and stateful widget classes. This not only improves readability but also optimizes rebuild performance.
Use Packages Wisely and Sparingly: The pub.dev registry has an immense collection of packages. However, carefully vet packages for regular maintenance, community support (likes, pub points), publisher credibility, and platform compatibility before adding them as dependencies. Avoid bloated or insecure projects that may break upon a new Dart SDK release.
Handle Asynchronous Code Gracefully: Always anticipate and handle potential errors in asynchronous code. Use try/catch/finally blocks extensively inside async functions to gracefully catch exceptions when awaiting Futures. Failure to do so can result in unhandled exceptions that silently fail or crash the application.
Write Comprehensive Tests: Take advantage of Dart’s exceptionally powerful testing tools (flutter_test or test package) to write unit tests for business logic, widget tests for UI components, and integration tests for end-to-end flows. This ensures application reliability across refactors and scaling.
Understand the Event Loop: Familiarize yourself with Dart’s single-threaded event-driven nature. Understand the difference between the Microtask queue and the Event queue. It’s crucial for avoiding UI jank in Flutter by offloading heavy, synchronous computations to background Isolates instead of blocking the main thread.

Referenced by

Programming Languages MOC

Dig deeper

Spot an error in this note?