Module 01: Dart Essentials

Variables: var, final, and const

Let's start with the most basic building block: putting values into boxes (variables).

Dart gives you three ways to declare a variable:

var name = 'Campbell';     // Mutable — can change later
final age = 22;            // Set once at runtime — can't change
const pi = 3.14159;        // Compile-time constant — baked in forever

var — The Flexible One

var greeting = 'Hello';
greeting = 'Hi there';  // Totally fine
greeting = 42;           // ERROR! Dart inferred greeting as String

Wait — why the error? Because Dart uses type inference. When you wrote var greeting = 'Hello', Dart quietly decided: "That's a String." From that point on, greeting is locked to String values. You can change what string it holds, but not what type it holds.

final — Set It and Forget It

final city = 'Portland';
city = 'Seattle';  // ERROR! final variables can't be reassigned

final timestamp = DateTime.now();  // Computed at runtime — that's fine

Use final when a value shouldn't change after it's assigned. In Flutter, you'll use final constantly — most widget properties are set once and never mutated.

const — The Immutable Hardliner

const gravity = 9.81;          // Known at compile time — perfect
const now = DateTime.now();     // ERROR! Can't compute at compile time

const is stricter than final. The value must be knowable before the program runs. Use it for true constants: math values, configuration strings, fixed lists.

The Type System

Dart is strongly typed — every value has a type, and the compiler checks that you're using types correctly. But thanks to type inference, you rarely have to write the types yourself.

Core Types

int count = 42;
double price = 9.99;
String name = 'Campbell';
bool isAwesome = true;

You can also let Dart figure out the type:

var count = 42;          // Dart infers int
var price = 9.99;        // Dart infers double
var name = 'Campbell';   // Dart infers String
var isAwesome = true;    // Dart infers bool

Both styles are equivalent. The explicit style is useful for documentation or when the type isn't obvious.

Collections: List, Map, Set

// List — ordered, allows duplicates (like an array)
var fruits = ['apple', 'banana', 'cherry'];
fruits.add('date');
print(fruits[0]);  // apple

// Map — key-value pairs (like a dictionary or object)
var scores = {
  'Campbell': 95,
  'Alice': 88,
  'Bob': 72,
};
print(scores['Campbell']);  // 95

// Set — unordered, no duplicates
var tags = {'flutter', 'dart', 'mobile'};
tags.add('flutter');  // Ignored — already exists
print(tags.length);   // 3

Type Annotations on Collections

List<String> names = ['Campbell', 'Alice'];
Map<String, int> ages = {'Campbell': 22, 'Alice': 25};
Set<double> temperatures = {72.5, 68.3, 75.1};

The angle brackets (<String>, <String, int>) are generics — they tell Dart what types the collection holds.

Null Safety: Dart's Safety Net

In many languages, any variable can be null at any time. This leads to the dreaded NullPointerException — the single most common runtime crash in software history. Tony Hoare, who invented null references, called it his "billion dollar mistake."

Dart says: no more. By default, variables cannot be null.

String name = 'Campbell';
name = null;  // ERROR! String can't be null

Making a Variable Nullable with ?

If you genuinely need a value that might be absent, you opt in with ?:

String? nickname = 'Cam';
nickname = null;  // Fine! String? means "String or null"

The ? is part of the type. String and String? are different types. The compiler tracks which is which and forces you to handle the null case.

The Operators: !, ??, ??=, ?.

Dart gives you a toolbox of operators for working with nullable types:

The ! operator — "Trust me, it's not null"

String? maybeName = getName();
String definitelyName = maybeName!;  // Crashes if null!

Use ! sparingly. It's an escape hatch that says "I know better than the compiler." If you're wrong, your app crashes.

The ?? operator — "Use this default if null"

String? maybeName = null;
String displayName = maybeName ?? 'Anonymous';
print(displayName);  // Anonymous

This is the safe way to handle nulls. Much better than !.

The ??= operator — "Assign only if currently null"

String? label;
label ??= 'Default';   // label is now 'Default'
label ??= 'Other';     // label stays 'Default' (not null, so no reassign)

The ?. operator — "Call this method only if not null"

String? name = null;
print(name?.toUpperCase());  // null (no crash!)
print(name?.length);         // null (no crash!)

String? name2 = 'Campbell';
print(name2?.toUpperCase()); // CAMPBELL

Functions

Functions in Dart are flexible, expressive, and — here's the fun part — they're first-class citizens, meaning you can pass them around like any other value.

Basic Functions

int add(int a, int b) {
  return a + b;
}

void greet(String name) {
  print('Hello, $name!');
}

Arrow Syntax (for one-liners)

If your function body is a single expression, use the arrow:

int add(int a, int b) => a + b;
void greet(String name) => print('Hello, $name!');

Same behavior, less ceremony.

Named Parameters

Named parameters make function calls readable — especially when there are many arguments:

void createUser({
  required String name,
  required String email,
  int age = 0,
  String role = 'viewer',
}) {
  print('$name ($email), age $age, role: $role');
}

// Calling it — order doesn't matter:
createUser(
  email: 'campbell@example.com',
  name: 'Campbell',
  role: 'admin',
);

Notice: - Named params are wrapped in {} - required means the caller must provide it - Without required, you must provide a default value

Optional Positional Parameters

String greet(String name, [String? title]) {
  if (title != null) {
    return 'Hello, $title $name!';
  }
  return 'Hello, $name!';
}

print(greet('Campbell'));          // Hello, Campbell!
print(greet('Campbell', 'Mr.'));   // Hello, Mr. Campbell!

Functions as First-Class Citizens

You can store functions in variables, pass them as arguments, and return them from other functions:

// Store a function in a variable
var multiply = (int a, int b) => a * b;
print(multiply(3, 4));  // 12

// Pass a function as an argument
var numbers = [3, 1, 4, 1, 5];
numbers.sort((a, b) => a.compareTo(b));
print(numbers);  // [1, 1, 3, 4, 5]

// Use built-in higher-order functions
var doubled = numbers.map((n) => n * 2).toList();
print(doubled);  // [2, 2, 6, 8, 10]

String Interpolation

Dart makes string building easy with the $ operator:

var name = 'Campbell';
var age = 22;

// Simple variable — just $
print('My name is $name');

// Expression — use ${}
print('Next year I will be ${age + 1}');
print('Name in caps: ${name.toUpperCase()}');
print('Name length: ${name.length}');

// Don't do this:
var message = 'Hello, ' + name + '! You are ' + age.toString() + ' years old.';

// Do this instead:
var message = 'Hello, $name! You are $age years old.';

There Are No Dumb Questions

Q: When should I use var vs writing the type explicitly? A: Use var when the type is obvious from the right side (var name = 'Campbell' — clearly a String). Write the type explicitly when it adds clarity, especially for complex types or when the right side doesn't make the type obvious (List<Map<String, dynamic>> data = fetchData()).

Q: What's the difference between final and const again? A: final is evaluated at runtime — you can assign final x = DateTime.now(). const is evaluated at compile time — the value must be fully determined before the program runs. In Flutter, you'll see const used with widget constructors: const Text('Hello') tells Flutter this widget never changes, enabling performance optimizations.

Q: Can I use single quotes and double quotes interchangeably? A: Yes! Dart treats 'hello' and "hello" identically. The convention is to use single quotes, but either works. Use the other kind when your string contains quotes: "It's Flutter time!" or 'She said "wow"'.

Q: Why does Dart need both List and Set? A: List preserves order and allows duplicates — use it when sequence matters. Set is unordered and automatically removes duplicates — use it when you need uniqueness. Checking "does this Set contain X?" is also much faster than checking a List.

Sharpen Your Pencil

Exercise 1: variables.dart

Create a file called variables.dart and write code that:

1. Declares a var, a final, and a const variable
2. Tries to reassign each one (comment out the lines that cause errors, and add a comment explaining why)
3. Creates a List<String> of your five favorite movies
4. Creates a Map<String, int> of three cities and their populations
5. Uses type inference (no explicit types) for at least two variables
6. Prints everything using string interpolation

void main() {
  var language = 'Dart';
  final birthYear = 2011;  // Dart was born in 2011
  const maxScore = 100;

  // Try reassignment:
  language = 'Flutter Dart';  // Works!
  // birthYear = 2012;       // Error: final can't be reassigned
  // maxScore = 200;         // Error: const can't be reassigned

  var movies = ['Inception', 'Interstellar', 'The Matrix', 'Arrival', 'Dune'];
  var populations = {
    'Portland': 652503,
    'Seattle': 749256,
    'San Francisco': 873965,
  };

  print('I code in $language, born in $birthYear');
  print('Max score is $maxScore');
  print('My top movie: ${movies[0]}');
  print('Portland population: ${populations["Portland"]}');
}

Exercise 2: null_safety.dart

Create a file that explores null safety:

1. Declare a nullable String? and a non-nullable String
2. Use the ?? operator to provide a default
3. Use the ?. operator to safely call a method on a nullable variable
4. Use ??= to assign a value only when null
5. Demonstrate why ! is dangerous (with a comment explaining the risk)

void main() {
  String? nickname;
  String name = 'Campbell';

  // ?? — default if null
  print('Nickname: ${nickname ?? "none set"}');

  // ?. — safe method call
  print('Uppercase nickname: ${nickname?.toUpperCase()}');  // null

  // ??= — assign if null
  nickname ??= 'Cam';
  print('Nickname after ??= : $nickname');  // Cam

  // ! — dangerous assertion
  String? maybeNull = 'I exist';
  print(maybeNull!.toUpperCase());  // Works, but risky
  // If maybeNull were null, the ! would crash the app at runtime
}

Exercise 3: functions.dart

Create a file that practices functions:

1. Write a function celsiusToFahrenheit using arrow syntax
2. Write a function describe that takes named parameters: required String name, int age = 0, String? hobby
3. Write a function applyOperation that takes two ints and a Function parameter, then applies that function
4. Use List.map() with a lambda to double every number in a list

double celsiusToFahrenheit(double c) => c * 9 / 5 + 32;

String describe({
  required String name,
  int age = 0,
  String? hobby,
}) {
  var result = '$name, age $age';
  if (hobby != null) {
    result += ', enjoys $hobby';
  }
  return result;
}

int applyOperation(int a, int b, int Function(int, int) operation) {
  return operation(a, b);
}

void main() {
  print('100°C = ${celsiusToFahrenheit(100)}°F');  // 212.0°F

  print(describe(name: 'Campbell', age: 22, hobby: 'coding'));
  print(describe(name: 'Alice'));

  print(applyOperation(10, 3, (a, b) => a + b));  // 13
  print(applyOperation(10, 3, (a, b) => a * b));  // 30

  var numbers = [1, 2, 3, 4, 5];
  var doubled = numbers.map((n) => n * 2).toList();
  print('Doubled: $doubled');  // [2, 4, 6, 8, 10]
}

📝 Module Quiz

Test what you learned. 45 seconds per question. Passing score is set per module. Your best attempt is saved in your browser so you can track progress -- nothing is sent to a server.

What's Next?

You now have the basics: variables, types, null safety, functions, and string interpolation. In Module 02, we level up to object-oriented programming in Dart — classes, constructors, inheritance, mixins, and more. This is where Dart really starts to shine, and it's essential for understanding how Flutter widgets work under the hood.