Dart: Dart Language Introduction — From Origin to Ecosystem

Dart — A language born for multi-platform, from Flutter to CLI, from Web to Server, one codebase runs everywhere.

1. What You'll Learn

• The birth background of Dart and Google's strategic positioning
• Core differences between Dart vs JavaScript / TypeScript / Kotlin
• Dart 3's three pillars: Null Safety / Pattern Matching / Sealed Classes
• The Dart ecosystem landscape: pub.dev / Flutter / server-side / CLI
• Overview of Bob's DataPipeline project and learning roadmap

2. A Real Developer's Story

(1) Pain Point: The Fragmentation Nightmare of Multi-Platform Development

Bob is a full-stack developer responsible for an e-commerce data analysis SaaS product. He needs to simultaneously maintain a web frontend (JavaScript), mobile apps (Kotlin + Swift), backend services (Go), and CLI tools (Python). Four languages, four toolchains, four codebases — fixing a single bug requires changes in four places. When the product manager requested a "real-time dashboard," Bob had to repeatedly weigh between Flutter and native development, with team communication costs soaring to 20 hours per week.

(2) Dart's Solution

Dart provides a unified tech stack: one language covers the frontend (Flutter Web), mobile (Flutter Mobile), backend (Dart shelf), and CLI (dart:io). Bob rewrote the entire project in Dart, and the core business logic only needs to be written once.

// Shared business logic - runs on CLI, Web, Mobile, Server
class DataPipeline {
  final String name;
  final int maxRecords;

  const DataPipeline({
    required this.name,
    this.maxRecords = 1000000,
  });

  String get summary => '$name: capacity ${maxRecords} records';
}

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

(3) Benefits

• Code reuse rate increased from 30% to 85%
• The team only needs to master one language, reducing communication costs by 60%
• Dart 3's Null Safety reduced runtime null pointer exceptions by 95%

3. The Birth and Evolution of Dart

(1) Background of Creation

Dart was released in 2011 by Google's Lars Bak and Kasper Lund, initially intended to replace JavaScript as the primary language for the web. The emergence of Flutter in 2015 changed Dart's destiny — transforming it from a "Web language" to a "multi-platform language."

graph LR
  A[Dart 1.0<br/>2011] --> B[Dart 2.0<br/>2018<br/>Strong typing]
  B --> C[Dart 2.12<br/>2021<br/>Null Safety]
  C --> D[Dart 3.0<br/>2023<br/>Records/Pattern/Sealed]
  D --> E[Dart 3.x<br/>2024+<br/>Wasm GC]

graph LR
  A[Dart 1.0<br/>2011] --> B[Dart 2.0<br/>2018<br/>Strong typing]
  B --> C[Dart 2.12<br/>2021<br/>Null Safety]
  C --> D[Dart 3.0<br/>2023<br/>Records/Pattern/Sealed]
  D --> E[Dart 3.x<br/>2024+<br/>Wasm GC]

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

(2) Google's Strategic Positioning

Dart is the sole official language for Flutter and is also the application-layer language for Google's internal Fuchsia OS. Google's investment in Dart is a long-term strategy, not an experimental project.

4. Dart vs Other Languages

(1) Core Difference Comparison

graph LR
  A[Dart] --> B[Null Safety]
  A --> C[Pattern Matching]
  A --> D[Sealed Classes]
  A --> E[AOT + JIT]
  A --> F[Isolate concurrency]

  G[JavaScript] --> H[Dynamic typing]
  G --> I[Single thread]

  J[TypeScript] --> K[Type erasure]
  J --> L[No runtime types]

  M[Kotlin] --> N[JVM dependent]
  M --> O[Coroutines]

graph LR
  A[Dart] --> B[Null Safety]
  A --> C[Pattern Matching]
  A --> D[Sealed Classes]
  A --> E[AOT + JIT]
  A --> F[Isolate concurrency]

  G[JavaScript] --> H[Dynamic typing]
  G --> I[Single thread]

  J[TypeScript] --> K[Type erasure]
  J --> L[No runtime types]

  M[Kotlin] --> N[JVM dependent]
  M --> O[Coroutines]

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

(2) Unique Advantages of Dart

• Sound Null Safety: The compiler guarantees non-nullable types will never be null, unlike TS which only checks at compile time.
• Isolate: True parallelism with no shared memory, avoiding race conditions.
• AOT + JIT Dual Mode: JIT hot reload during development, AOT high performance for release.
• Dart 3 Feature Triad: Records / Pattern Matching / Sealed Classes launched together.

5. The Three Pillars of Dart 3

(1) Null Safety

Sound Null Safety divides types into nullable T? and non-nullable T. The compiler guarantees at compile-time that non-nullable types will never be null.

// Non-nullable - compiler guarantees non-null
String name = 'Bob';

// Nullable - must check before use
String? nickname = null;

// Safe access
int length = nickname?.length ?? 0;

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

(2) Pattern Matching

Dart 3 introduced a complete pattern matching system, supporting destructuring, if-case, switch expressions, and exhaustive checks.

// Switch expression with pattern matching
String describe(Object value) => switch (value) {
  int i => 'Integer: $i',
  double d => 'Double: $d',
  String s => 'String: $s',
  _ => 'Unknown type',
};

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

(3) Sealed Classes

A sealed class restricts subclasses to within the same library, allowing the compiler to guarantee switch exhaustiveness.

sealed class DataSource {}
class ApiSource extends DataSource { final String endpoint; ApiSource(this.endpoint); }
class FileSource extends DataSource { final String path; FileSource(this.path); }
class DatabaseSource extends DataSource { final String connectionString; DatabaseSource(this.connectionString); }

// Exhaustive switch - compiler checks all cases
String describe(DataSource source) => switch (source) {
  ApiSource(:final endpoint) => 'API: $endpoint',
  FileSource(:final path) => 'File: $path',
  DatabaseSource(:final connectionString) => 'DB: $connectionString',
};

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

6. Dart Ecosystem Landscape

(1) Core Ecosystem Components

graph LR
  A[Dart Ecosystem] --> B[Flutter<br/>Mobile/Desktop/Web]
  A --> C[pub.dev<br/>Package Registry]
  A --> D[Server-side<br/>shelf/dart:io]
  A --> E[CLI Tools<br/>args/dart:io]
  A --> F[Web<br/>dart2js/dart2wasm]
  A --> G[Testing<br/>test package]
  A --> H[Code Generation<br/>build_runner]

graph LR
  A[Dart Ecosystem] --> B[Flutter<br/>Mobile/Desktop/Web]
  A --> C[pub.dev<br/>Package Registry]
  A --> D[Server-side<br/>shelf/dart:io]
  A --> E[CLI Tools<br/>args/dart:io]
  A --> F[Web<br/>dart2js/dart2wasm]
  A --> G[Testing<br/>test package]
  A --> H[Code Generation<br/>build_runner]

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

▶ Example

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

: pub.dev package search

Bob searches for data processing related packages on pub.dev:

// pubspec.yaml dependencies for DataPipeline
// dependencies:
//   args: ^2.4.2        # CLI argument parsing
//   http: ^1.2.0        # HTTP client
//   csv: ^6.0.0         # CSV parsing
//   sqlite3: ^2.4.0     # SQLite database
//   path: ^1.9.0        # Path manipulation

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

7. Overview of Bob's DataPipeline Project

(1) Project Definition

DataPipeline is an e-commerce data analysis CLI tool developed by Bob, processing millions of order records to output reports usable by a SaaS dashboard.

▶ Example

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

: Project Vision

// DataPipeline project overview
// Input:  1.2M e-commerce orders (CSV / API / Database)
// Process: Filter, aggregate, transform in parallel
// Output: Dashboard-ready reports (JSON / CSV / HTML)

void main() {
  print('DataPipeline v1.0.0');
  print('Processing capacity: 1,000,000+ orders');
  print('Output formats: JSON, CSV, HTML');
}

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

(2) Learning Roadmap

graph TD
  subgraph Phase1[Phase 1: Fundamentals]
    L1[Lesson 1: Introduction]
    L2[Lesson 2: Installation]
    L3[Lesson 3: Basic Syntax]
    L4[Lesson 4: Variables & Types]
    L5[Lesson 5: Operators]
    L6[Lesson 6: Control Flow]
  end

  subgraph Phase2[Phase 2: Core Features]
    L7[Lesson 7: Functions]
    L8[Lesson 8: Classes & Objects]
    L9[Lesson 9: Collections]
    L10[Lesson 10: Exception Handling]
    L11[Lesson 11: Generics]
    L12[Lesson 12: Enums & Extensions]
  end

  subgraph Phase3[Phase 3: Advanced]
    L13[Lesson 13: Null Safety]
    L14[Lesson 14: Future / async-await]
    L15[Lesson 15: Stream]
    L16[Lesson 16: Dart 3 Features]
    L17[Lesson 17: Isolates]
    L18[Lesson 18: Metaprogramming]
  end

  subgraph Phase4[Phase 4: Operations]
    L19[Lesson 19: Package Management]
    L20[Lesson 20: Testing]
    L21[Lesson 21: Code Generation]
    L22[Lesson 22: Dart & Flutter]
  end

  subgraph Phase5[Phase 5: Project]
    L23[Lesson 23: Project Design]
    L24[Lesson 24: Optimization & Release]
  end

  Phase1 --> Phase2 --> Phase3 --> Phase4 --> Phase5

graph TD
  subgraph Phase1[Phase 1: Fundamentals]
    L1[Lesson 1: Introduction]
    L2[Lesson 2: Installation]
    L3[Lesson 3: Basic Syntax]
    L4[Lesson 4: Variables & Types]
    L5[Lesson 5: Operators]
    L6[Lesson 6: Control Flow]
  end

  subgraph Phase2[Phase 2: Core Features]
    L7[Lesson 7: Functions]
    L8[Lesson 8: Classes & Objects]
    L9[Lesson 9: Collections]
    L10[Lesson 10: Exception Handling]
    L11[Lesson 11: Generics]
    L12[Lesson 12: Enums & Extensions]
  end

  subgraph Phase3[Phase 3: Advanced]
    L13[Lesson 13: Null Safety]
    L14[Lesson 14: Future / async-await]
    L15[Lesson 15: Stream]
    L16[Lesson 16: Dart 3 Features]
    L17[Lesson 17: Isolates]
    L18[Lesson 18: Metaprogramming]
  end

  subgraph Phase4[Phase 4: Operations]
    L19[Lesson 19: Package Management]
    L20[Lesson 20: Testing]
    L21[Lesson 21: Code Generation]
    L22[Lesson 22: Dart & Flutter]
  end

  subgraph Phase5[Phase 5: Project]
    L23[Lesson 23: Project Design]
    L24[Lesson 24: Optimization & Release]
  end

  Phase1 --> Phase2 --> Phase3 --> Phase4 --> Phase5

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

▶ Example

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

: DataPipeline preview code

// DataPipeline preview - what you will build
void main() {
  // Step 1: Define data source
  final source = ApiSource('https://api.example.com/orders');

  // Step 2: Create pipeline
  final pipeline = DataPipeline(
    name: 'E-Commerce Analytics',
    maxRecords: 1200000,
  );

  // Step 3: Process and output
  print(pipeline.summary);
  // Output: E-Commerce Analytics: capacity 1200000 records
}

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

8. Complete Example: DataPipeline Project Skeleton

// ============================================
// DataPipeline Project Skeleton
// A CLI tool for e-commerce data analytics
// ============================================

// Data source types (sealed class for exhaustive matching)
sealed class DataSource {}

class ApiSource extends DataSource {
  final String endpoint;
  ApiSource(this.endpoint);
}

class FileSource extends DataSource {
  final String path;
  FileSource(this.path);
}

// Core pipeline class
class DataPipeline {
  final String name;
  final int maxRecords;
  DataSource? source; // nullable - may not be configured yet

  DataPipeline({
    required this.name,
    this.maxRecords = 1000000,
  });

  String get summary => '$name: capacity ${maxRecords} records';

  String describeSource() {
    if (source == null) return 'No source configured';
    return switch (source!) {
      ApiSource(:final endpoint) => 'API source: $endpoint',
      FileSource(:final path) => 'File source: $path',
    };
  }
}

// Entry point
void main() {
  final pipeline = DataPipeline(
    name: 'E-Commerce Analytics',
    maxRecords: 1200000,
  );

  pipeline.source = ApiSource('https://api.example.com/orders');

  print('=== DataPipeline ===');
  print(pipeline.summary);
  print(pipeline.describeSource());
}

> Output: Run in a local DartPad or with `dart run`. All examples in the Dart course are based on Dart 3.x / Flutter 3.x, and results may vary slightly with SDK version.

Output:

=== DataPipeline ===
E-Commerce Analytics: capacity 1200000 records
API source: https://api.example.com/orders

❓ FAQ

Q: What is the relationship between Dart and Flutter? A: Dart is the sole official programming language for Flutter, which is a UI framework built with Dart. Learning Dart is a prerequisite for learning Flutter.

Q: Can Dart replace JavaScript for frontend development? A: Dart can be compiled to JavaScript via dart2js or to WebAssembly via dart2wasm. However, the web ecosystem is still dominated by JS. Dart's strength lies in Flutter for the web.

Q: Is Dart 3's Null Safety mandatory? A: Yes, Dart 3 enables Sound Null Safety by default. Legacy code needs migration, but gradual migration has been supported since Dart 2.12.

Q: Is Dart suitable for backend development? A: Yes. Dart has backend frameworks like shelf and dart_frog, and its Isolate concurrency model can handle high-concurrency scenarios. However, its ecosystem is not as mature as Go/Java.

Q: Is it difficult to learn Dart if I already have TypeScript experience? A: Not difficult. Dart and TS have similar type systems, but Dart's Sound Null Safety and Isolate are new concepts that require focused learning.

Q: How is Dart's performance? A: After AOT compilation, performance is close to Go/Java. JIT mode supports hot-reload development. Wasm GC support greatly enhances web performance.

Q: How is the quality of packages on pub.dev? A: pub.dev has a quality scoring system (pub points) covering platform support, documentation coverage, etc. Popular packages like http and args are high quality, but niche packages should be evaluated individually.

📖 Summary

• Dart was released by Google in 2018. Dart 2.0 established strong typing, and Dart 3 introduced its three pillars in 2023.
• The three pillars of Dart 3: Null Safety (eliminates null pointers), Pattern Matching (type destructuring), Sealed Classes (exhaustive checks).
• Core differences between Dart vs JS/TS/Kotlin: Sound type system, Isolate concurrency, AOT+JIT dual mode.
• The Dart ecosystem covers five major areas: Flutter, pub.dev, Server-side, CLI, and Web.
• Bob's DataPipeline project will span 24 lessons, from Hello World to a complete CLI tool.
• Learning roadmap: 5 Phases from beginner to practical application, progressing step by step.

📝 Exercises

1. Basic (Difficulty ⭐): Visit pub.dev, search for the http package, check its pub points rating, and record the list of supported platforms.
2. Intermediate (Difficulty ⭐⭐): Compare Dart with your most familiar programming language (JS/Python/Java, etc.), list 3 advantages and 3 disadvantages of Dart, and write a brief comparison table.
3. Challenge (Difficulty ⭐⭐⭐): Sketch a module division diagram for the DataPipeline project, considering what components are needed for the three stages: data input, processing, and output.

← Previous Lesson | Next Lesson →

Web-Tutorial Tech Team

A team of developers maintaining programming tutorials. Each tutorial is written and reviewed by developers with expertise in that field. We work to keep our content accurate and reliable — if you spot an issue, please let us know.

About Us