Sound Null Safety — Flutter Course

What you'll learn

Use non-nullable defaults, flow analysis, nullable types, and null-aware operators to prevent an entire class of runtime failures. The lesson turns the APIs into a repeatable engineering workflow instead of a collection of isolated snippets.

By the end of this lesson, you'll be able to:

Apply Non-nullable defaults in a production-shaped Flutter feature
Apply Nullable types in a production-shaped Flutter feature
Apply Flow analysis in a production-shaped Flutter feature
Apply Null-aware operators in a production-shaped Flutter feature

Core mental model

Connect each API to the decision it supports. Flutter code stays maintainable when state, ownership, lifecycle, and platform boundaries are explicit.

Concept	What it means	Decision rule
Non-nullable default	A value cannot be null unless its type says so	Model required domain data with non-nullable fields
Flow promotion	Analyzer evidence narrows a nullable or broader type	Use checks and patterns so the analyzer can prove safety
Null assertion	The programmer overrides static uncertainty with !	Reserve for invariants that cannot be expressed more safely

Professional workflow

Work in small vertical slices and keep behavior observable from the first iteration.

Define the null-safe profile boundary boundary: user goal, inputs, visible states, ownership, and expected failures.
Build the smallest working vertical slice with typed data and explicit dependencies.
Represent loading, empty, success, and failure behavior where the feature can encounter them.
Verify logic away from the UI, then exercise the rendered behavior at its public boundary.
Inspect lifecycle, accessibility, performance, security, and platform behavior before widening the feature.
Refactor only after behavior is protected by repeatable evidence.

Protect the frame

Keep build methods predictable, move side effects to explicit owners, and measure before introducing caches, isolates, or architectural layers.

Guided Flutter lab

Build a focused null-safe profile boundary slice

This compact example keeps the important ownership and data-flow decisions visible so the behavior is easy to extend and test.

lib/profile.dart

record Profile(String id, String? displayName);

String greeting(Profile? profile) {
  if (profile == null) return 'Welcome, guest';

  final name = profile.displayName?.trim();
  return switch (name) {
    final value? when value.isNotEmpty => 'Welcome, $value',
    _ => 'Welcome, learner',
  };
}

Production practice

Contract

Define the null-safe profile boundary inputs, outputs, owner, lifecycle, visible states, and platform assumptions before selecting APIs or packages.

Verification

Protect pure rules with unit tests and the rendered public contract with widget or integration evidence; include one unavailable or failure case.

Operations

Keep dependencies replaceable, log actionable context without user secrets, and measure user-visible behavior before optimizing.

Common failure mode

Adding ! until code compiles merely moves uncertainty to runtime; redesign the boundary, check once, and let flow analysis carry the proof.

Independent workshop

Extend the guided lab into a review-ready null-safe profile boundary feature that fits the running course portfolio app.

Your finished workshop must include:

Non-nullable defaults
Nullable types
Flow analysis
Null-aware operators
late and assertions
Automated verification and a short design note

Definition of done

Demonstrate the happy path, an empty or unavailable state, and at least one failure path. Add an automated check and a short note explaining one design decision.

Recap & quick check

Key takeaways

Non-nullable default: Model required domain data with non-nullable fields
Flow promotion: Use checks and patterns so the analyzer can prove safety
Null assertion: Reserve for invariants that cannot be expressed more safely

Quick check

1. Which rule best applies to Non-nullable default?

2. Which rule best applies to Flow promotion?

3. Which rule best applies to Null assertion?

Next: Classes, Objects & Immutability