What is Dart? History & Birth

Every great technology has an origin story. Dart's story begins not with a grand vision of mobile apps and cross-platform development — it begins with frustration. Frustration with JavaScript.

Let's travel back to 2011 and understand where Dart came from, why it was created, and how it evolved into what it is today.

---

🕰️ The Year Was 2011

The web was booming. JavaScript was everywhere. And inside Google, a group of engineers had a problem:

JavaScript, at scale, is a nightmare.

Google was building massive web applications — Gmail, Google Docs, Google Maps — and JavaScript's dynamic typing, lack of structure, and performance limitations were causing real pain. Bugs were hard to track. Large codebases were hard to maintain. Performance was inconsistent.

Something needed to change.

---

🎭 GOTO Conference 2011 — Dart's Public Birth

On October 10, 2011, at the GOTO Conference in Aarhus, Denmark, Google made a quiet but significant announcement: a new programming language called Dart.

The initial press release described Dart as:

The goals were ambitious:

• Replace JavaScript as the primary language of the web browser
• Provide a structured, scalable language for large applications
• Offer optional typing (at the time — later became mandatory)
• Compile to both native code (Dart VM) and JavaScript (for browser compatibility)

The reception was... mixed. The JavaScript community was skeptical. "Why create a new language when JavaScript exists?" But inside Google, the team pressed on.

---

👨‍💻 The Creators: Lars Bak & Kasper Lund

Dart wasn't created by accident. It was engineered by two of the most accomplished virtual machine engineers in the world.

Lars Bak

Lars Bak is a legendary figure in programming language implementation:

• Worked on Smalltalk VMs at Animorphic Systems
• Joined Sun Microsystems to work on Java HotSpot VM — the JIT compiler that made Java fast
• Joined Google to create V8 — the JavaScript engine that powers Chrome and Node.js
• Then built Dart — combining all his VM expertise

Kasper Lund

Kasper Lund was Lars Bak's longtime collaborator:

• Co-designed the V8 JavaScript engine
• Co-authored Dart's original design
• Focused on compiler technology and language design

Together, they designed a language that addressed JavaScript's weaknesses while staying approachable for web developers.

---

🌐 Dart's Original Purpose — Replace JavaScript?

Dart's original goal was bold: become the primary language for web browsers, replacing or supplementing JavaScript.

Google even built a browser called Dartium — a version of Chromium that could run Dart code natively (without transpiling to JavaScript). The dream was that eventually, all browsers would ship a Dart VM alongside the JavaScript engine.

Original Dart Vision (2011):
┌──────────────┐     compile      ┌────────────┐
│  Dart Code   │ ─────────────▶  │ Dart VM in │
│              │                 │  Browser   │
└──────────────┘                 └────────────┘
       │
       │ also compile to
       ▼
┌──────────────┐
│  JavaScript  │  (for browsers without Dart VM)
└──────────────┘

This plan never materialized. Other browser vendors (Mozilla, Apple, Microsoft) declined to adopt a Dart VM. The idea of replacing JavaScript in the browser quietly died around 2015.

But Dart itself? Dart survived. And found something far more important.

---

🦋 Dart's Evolution — From Browser to Flutter

The real turning point came from an unlikely direction: mobile development.

Timeline of Dart's Evolution

2011 ─── Dart announced at GOTO Conference
          Goal: structured web programming

2013 ─── Dart 1.0 released
          Focus: browser apps, compile to JS

2015 ─── Dartium deprecated
          Browser replacement dream fades
          Dart pivots to server + tooling

2017 ─── Flutter alpha released
          🎯 PIVOTAL MOMENT: Flutter uses Dart
          Dart finds its true calling

2018 ─── Dart 2.0 released
          Complete type system overhaul
          "Sound type system" introduced
          Optional typing removed → all types required
          Flutter 1.0 released
          
2021 ─── Dart 2.12 — Sound Null Safety
          Major safety improvement
          Null errors become compile-time errors

2023 ─── Dart 3.0 — Records, Patterns, Class Modifiers
          Language becomes significantly more expressive

2024 ─── Dart 3.x — WebAssembly (WASM) support
          Dart in the browser — the right way this time

2026 ─── Dart is the backbone of the Flutter ecosystem
          2M+ apps, 40K+ packages on pub.dev

The Flutter Miracle

When the Flutter team chose Dart as their language in 2015-2017, it was a controversial decision. Many expected Flutter to use JavaScript (like React Native) or Kotlin.

But Flutter's creators chose Dart for specific technical reasons:

1. AOT Compilation — Dart can compile to native machine code ahead of time
2. JIT Compilation — Dart can also JIT compile (enabling Flutter's famous Hot Reload)
3. No JavaScript Bridge — Flutter+Dart runs natively, not through a JS bridge
4. Garbage Collection — Dart's GC is optimized for smooth UI (no GC pauses during scrolling)
5. Simple Syntax — Easy for both beginners and experienced developers

---

🔑 Dart's Key Characteristics

1. Strongly Typed

Every value in Dart has a type. The compiler knows the type of every variable:

dart
void main() {
  String name = "Dart";        // ✅ String type
  int version = 3;             // ✅ int type
  double pi = 3.14159;         // ✅ double type
  bool isAwesome = true;       // ✅ bool type
  
  // Dart infers types too:
  var language = "Dart";       // inferred as String
  var year = 2026;             // inferred as int
  
  // Type errors caught at COMPILE TIME:
  // int count = "hello";      // ❌ Compile error! String ≠ int
}

2. Object-Oriented Programming

Everything in Dart is an object — even primitive types like int and bool:

dart
void main() {
  // Even numbers are objects with methods!
  int number = -42;
  print(number.abs());       // 42 — calling method on int object
  print(number.isNegative);  // true — accessing property

  String text = "  hello dart  ";
  print(text.trim());        // "hello dart" — String is a full object
  print(text.toUpperCase()); // "  HELLO DART  "
  print(text.length);        // 15

  // Lists are objects too
  List<int> numbers = [3, 1, 4, 1, 5];
  numbers.sort();
  print(numbers); // [1, 1, 3, 4, 5]
}

3. Garbage Collected

You don't manually manage memory in Dart. The garbage collector automatically frees memory when objects are no longer needed:

dart
void main() {
  // Dart manages memory for you
  for (int i = 0; i < 1000; i++) {
    String temp = "Temporary string $i";
    // When temp goes out of scope, Dart's GC handles cleanup
    // No malloc, no free, no memory leaks from this code
  }
  print("Done! No memory leaks.");
}

4. Compiled Language (Two Modes)

Dart Compilation Modes:

JIT (Just-In-Time) ─── During DEVELOPMENT
  → Faster build cycles
  → Enables Hot Reload (change code → see instantly)
  → Used by Flutter's debug mode

AOT (Ahead-Of-Time) ─── For PRODUCTION
  → Compiled to native machine code
  → Maximum runtime performance
  → Smaller, faster apps
  → Used by Flutter's release mode

5. Sound Null Safety

Since Dart 2.12, null safety is built into the language — variables cannot be null unless explicitly declared as nullable:

dart
void main() {
  // Non-nullable (default) — CANNOT be null
  String name = "Dart";
  // name = null; ❌ Compile error!

  // Nullable — CAN be null (use ? suffix)
  String? nickname = null;  // ✅ Allowed

  // Safe access with null-aware operators
  print(nickname?.length);          // null (no crash!)
  print(nickname ?? "No nickname"); // "No nickname" (default value)

  // Force unwrap (use only when SURE it's not null)
  nickname = "Dart King";
  print(nickname!.length); // 9
}

---

👋 Your First Dart Program: Hello World

Let's see Dart in action with the most fundamental program:

dart
void main() {
  print("Hello, World!");
}

Output:

Hello, World!

Simple. Let's break it down:

Part	Meaning
void	Return type — this function returns nothing
main	The entry point — execution starts here
()	Parameters — main takes no parameters
{ ... }	Function body — the code to execute
print(...)	Built-in function to output text
"Hello, World!"	A String literal

Hello World — Expanded Version

dart
void main() {
  // Variables
  String language = "Dart";
  int year = 2011; // Year Dart was created
  int currentYear = 2026;
  int age = currentYear - year;

  // String interpolation — use $ to embed values
  print("Hello from $language!");
  print("Dart was born in $year.");
  print("It is $age years old in $currentYear.");
  print("And it's more powerful than ever! 🎯");
}

Output:

Hello from Dart!
Dart was born in 2011.
It is 15 years old in 2026.
And it's more powerful than ever! 🎯

---

🏛️ Dart's Architecture Overview

┌─────────────────────────────────────────┐
│              Your Dart Code              │
└──────────────────┬──────────────────────┘
                   │
        ┌──────────┴──────────┐
        │                     │
   JIT Compiler          AOT Compiler
  (Development)          (Production)
        │                     │
   Dart VM               Native Binary
   (Hot Reload!)         (.exe / .apk / .ipa)
        │                     │
   Runs in Debug        Runs on Device

---

🌍 Where Dart Runs Today

dart
void main() {
  // Dart can target ALL of these platforms:
  final platforms = [
    "Android (native ARM)",
    "iOS (native ARM)",
    "Web (JavaScript compilation)",
    "Web (WebAssembly - WASM)",
    "Windows (native x64)",
    "macOS (native ARM64/x64)",
    "Linux (native x64)",
    "Server / CLI (Dart VM)",
  ];

  print("Dart runs on ${platforms.length} platforms:");
  for (int i = 0; i < platforms.length; i++) {
    print("  ${i + 1}. ${platforms[i]}");
  }
}

Output:

Dart runs on 8 platforms:
  1. Android (native ARM)
  2. iOS (native ARM)
  3. Web (JavaScript compilation)
  4. Web (WebAssembly - WASM)
  5. Windows (native x64)
  6. macOS (native ARM64/x64)
  7. Linux (native x64)
  8. Server / CLI (Dart VM)

---

📝 Summary

Topic	Key Fact
Created by	Lars Bak & Kasper Lund (also made V8!)
Announced	October 10, 2011 at GOTO Conference
Original goal	Replace/supplement JavaScript in browsers
Reality	Powers Flutter — the world's #1 cross-platform framework
Type system	Strongly typed, sound null safety (since 2.12)
Paradigm	Object-Oriented, functional elements
Memory	Garbage collected (GC tuned for UI)
Compilation	JIT (dev) + AOT (production)
Current version	Dart 3.x (2026)
Hello World	void main() { print("Hello!"); }

In the next lesson, we'll look at how Dart evolved through its major versions — from 1.0 to 3.x — and understand what each version brought to the table.