Deep Dives
In-depth technical explorations of mobile development, architecture patterns, and system design.
Master the Dart programming language from first principles to advanced features.
Async
Futures in Dart — Async, Await, and the Event Loop
Futures represent values that don't exist yet. Understanding them unlocks network calls, file I/O, and responsive Flutter apps.
Streams in Dart — Multiple Values Over Time
Streams deliver sequences of asynchronous events. From user input to network data to real-time updates, streams power reactive Dart applications.
Isolates in Dart — True Parallelism Without Shared Memory
Heavy computation freezes your Flutter app. Isolates give you parallel execution with zero race conditions — because they share nothing.
Collections
Data Foundations
Bits and Transistors — The Foundation of Everything
Every Dart variable, every Flutter widget, every app you build rests on a foundation of transistors switching between 0 and 1. Let's understand how.
Booleans in Dart — Singletons, Null Safety, and Logical Operators
Two values, infinite uses. A deep dive into how Dart stores true and false, what bool? actually changes, and how logical operators really work.
Variables and Keywords — var, final, const, and Friends
How Dart stores and protects data. Understanding var, final, const, late, and dynamic unlocks safe, predictable code.
Integers in Dart — Smi, Mint, BigInt, and Typed Buffers
Every int in Dart hides a strategy. A deep dive into how Dart stores numbers, what boxing costs, and how typed buffers let you write code that flies.
Doubles in Dart — IEEE 754, Precision, and Special Values
How a few clever switches let us store fractions, why 0.1 + 0.2 isn't 0.3, and how to work with floating-point numbers without getting bitten.
Doubles in Dart, Part 2 — Memory and IEEE 754 Edge Cases
How Dart actually stores doubles in memory, why doubles are always boxed, and the edge cases — subnormals, catastrophic cancellation, the 53-bit cliff, and rounding modes.
Strings in Dart — UTF-16, Runes, and Grapheme Clusters
How Dart stores text, why string.length can lie, and what it takes to correctly count characters in a world of emoji and combining marks.
Collections in Dart — Lists, Sets, Maps, and Performance Trade-offs
Three collections, three problems. How Dart organises bulk data — from phone contacts to high-performance arrays — and how to pick the right tool for the job.
Primitive Computation
Functions in Dart — First-Class, Closures, and Tear-offs
Functions are objects. They can be passed around, returned, and stored — and that changes everything about how we write code.
Classes in Dart — Constructors, Inheritance, and Object Identity
How Dart organises code into objects, the many ways to construct them, and what really happens when we say two things are equal.
Mixins in Dart — Reusable Behaviour Without Inheritance
When inheritance forces us to choose one parent, mixins let us combine behaviours freely. Here's how they work and when to use them.
Extensions in Dart — Adding Methods to Any Type
Extension methods let us add functionality to existing types — even ones we don't control. Here's how they work and when they're the right tool.
The Platform
Dart: The Platform — VM, Compilation, and Runtime
Dart is not just a language — it is a platform. JIT for development, AOT for production, tree shaking for size, and a generational garbage collector that makes Flutter feel instant.
Dart FFI — Calling Native Code and Breaking Out of the VM
When Dart's sandbox isn't enough. How to call C libraries, allocate native memory, and bridge the gap between managed and unmanaged code.
Type System
Null Safety in Dart — The Billion-Dollar Mistake, Fixed
The most common runtime crash in programming history, and how Dart eliminates it at compile time. A deep dive into nullable types, null-aware operators, flow analysis, and the late keyword.
Generics in Dart — Type Safety Without the Repetition
Write code once, use it with any type. How Dart's generics give us flexible, reusable APIs while keeping the type checker happy.
Enhanced Enums in Dart — Fields, Methods, and Type-Safe Switching
Enums are more than named constants. Dart 2.17 lets enums hold data, implement interfaces, and provide methods — bringing the power of classes to the simplicity of enumeration.
Records in Dart — Lightweight, Immutable, and Structural
Dart 3 introduced records — anonymous, immutable data structures with built-in equality. They fill the gap between ad-hoc Maps and full-blown classes.
Patterns in Dart — Destructuring and Matching in One
Dart 3 introduced patterns — a way to destructure data and match its shape at the same time. They make switch statements powerful, if-case expressive, and variable declarations cleaner.
Sealed Classes in Dart — Exhaustive Switching and Algebraic Data Types
When the compiler knows all possible subtypes, it can prove your switch is complete. Sealed classes bring this superpower to Dart 3.
Class Modifiers in Dart — abstract, base, final, interface, sealed, and mixin
Dart 3 introduced powerful class modifiers that control how your classes can be extended, implemented, and instantiated. Learn when to use each one.