Variables: Boxes That Remember

The first thing any app needs to do is remember things. What is the user's name? What is their score? Is dark mode on? We store these values in variables. Think of a variable as a labelled cardboard box: you write a name on the outside, and you place a value inside.

Three variables, three different types of data.

The Essential Data Types

Notice the word before each variable name — String, int, bool. That is the type: it tells Dart exactly what kind of value lives in the box. These are the types you will use constantly:

• String — text of any length, wrapped in quotes: 'Hello', 'sara@mail.com'.
• int — a whole number with no decimal point: 0, 25, -7.
• double — a number with a decimal point: 3.14, 9.99, 0.5. Used for prices, measurements, ratings.
• bool — short for "boolean," holds only true or false. The foundation of all decisions.

var, final and const

You have three more handy keywords for creating variables:

• var — lets Dart figure out the type automatically from the value. var city = 'Cairo'; is understood as a String. Convenient and very common.
• final — a box you fill once and can never change again. Great for values that should stay fixed, like a user's date of birth.
• const — like final, but the value is locked in the moment the app is built. Use it for true constants, like const pi = 3.14159;.

The late Keyword

Sometimes you want to declare a variable but you can't give it a value immediately (e.g., waiting for data from the internet). You can use the late keyword to tell Dart: "I promise I will give this a value before I use it."

Be careful: if you break that promise and try to use it before assigning a value, your app will crash!

Deep Dive: The dynamic Type

Sometimes you genuinely do not know what type of data you will receive (e.g., parsing a complex JSON response). Dart offers the dynamic keyword, which disables type checking for that variable. It can be a String now, and an int later.

However, use dynamic as a last resort! It completely removes Dart's safety net. If you try to call a String method on mystery while it holds a number, your app will crash at runtime. Prefer explicitly defining types whenever possible to keep your codebase robust.

Deep Dive: late and Flutter Controllers

In Flutter, you often create controllers (like TextEditingController or AnimationController) that need access to the widget's context, which isn't available at the exact moment the variable is created. The late keyword is the professional's solution: it promises Dart the variable will be initialized in the initState() method before it's ever drawn on screen.

Animated Example

Values being stored in named boxes

Play

String name"Alex"

int age25

bool isCooltrue

1. A box named name of type String stores the text "Alex".
2. A box age of type int holds the whole number 25.
3. A box isCool of type bool holds true. Each type guards what can go inside.

Doing Things with Values: Operators

Storing values is useful, but the real power comes from combining and comparing them. We do that with operators — small symbols that perform an action on your values. You already know most of them from school maths.

Arithmetic Operators

That last one, % (called "modulo"), is more useful than it looks. It gives the remainder after division. A classic trick: number % 2 == 0 is true only for even numbers — perfect for "colour every other row" style logic.

Comparison Operators (they produce true or false)

These compare two values and hand back a boolean. They are the raw material of every decision an app makes:

• == — equal to (note: two equals signs; a single = means "assign").
• != — not equal to.
• >, < — greater than, less than.
• >=, <= — greater than or equal, less than or equal.

Logical Operators (combining conditions)

Often you need to check more than one thing at once. Logical operators join booleans together:

• && (AND) — true only if both sides are true.
• || (OR) — true if at least one side is true.
• ! (NOT) — flips true to false and vice-versa.

String Interpolation — Putting Values Into Text

You will constantly need to slot a variable's value into a sentence. Dart makes this beautifully clean with the $ symbol, a technique called string interpolation:

$ inserts a variable; ${ } inserts a whole expression.

Deep Dive: The Cascade Operator (..)

Dart has a unique operator called the cascade operator (..). It allows you to perform a sequence of operations on the same object without having to repeatedly type the object's name. It's incredibly useful when setting up complex UI components in Flutter.

Deep Dive: Null-Aware Operators

Dart shines with operators designed specifically to handle missing data (nulls) safely without crashing. The null-aware assignment ??= only assigns a value if the variable is currently null. The null-aware spread operator ...? adds a list into another list only if it actually exists.

Animated Example

Operators combining and comparing values

Play

> 2 + 3 * 4 → 14 // * before +

> 'Ria' + ' Academy' → 'Ria Academy'

> 10 == '10' → false // number ≠ text

> age >= 18 && hasTicket → true

1. Maths follows order of operations: * before +, giving 14.
2. The + operator also joins strings together.
3. == compares value and type — a number is never equal to text.
4. && is true only when both sides are true — the core of real decisions.

Making Decisions with If / Else

An app that always does the exact same thing no matter what would be useless. Apps must react — to a tap, a login, a value. The tool that lets code make a choice is the if statement, and it maps almost perfectly onto everyday English.

The Basic if

It reads exactly how it sounds: "IF this condition is true, THEN run this block of code."

The part in the round brackets — userAge >= 18 — is the condition. It always boils down to true or false. If it is true, the code in the curly braces runs. If it is false, that block is simply skipped.

Adding an else

Usually you also want a plan for when the condition is false. That is what else is for: "OTHERWISE, do this instead."

Every login screen you have ever used runs this exact pattern behind the scenes: if the password is correct, open the app; else, show an error.

Multiple Paths with else if

When there are several possibilities, chain them together with else if. Dart checks each condition from top to bottom and runs the first one that is true:

The switch Statement

When you are checking one variable against many exact values, a switch can be cleaner than a long chain of else ifs:

Deep Dive: The Ternary Operator (? :)

Often, you need an if/else just to decide which value to assign to a variable. The ternary operator condenses this into a single, elegant line. It asks a question (?), provides the true answer, then a colon (:), and the false answer.

You will use this constantly in Flutter to show one widget or another based on state (e.g., isLoading ? LoadingSpinner() : UserProfile()).

Deep Dive: Pattern Matching in Dart 3

Dart 3 introduced massive upgrades to logic flow with Pattern Matching. It allows you to deeply inspect the shape and contents of data inside a switch statement or an if-case. It replaces messy chains of if statements with elegant, declarative logic.

The case checks if the list has exactly 3 items, starts with 'user', and binds the next two items directly to variables name and age. This is a game-changer for parsing JSON.

Animated Example

The same condition, two different results

Play

age = ?

✓ Access granted

✗ Access denied

1. First run: the user's age is 20.
2. 20 >= 18 is true, so the if block runs — access granted.
3. Second run: age is 15. 15 >= 18 is false, so the else runs — denied.

Loops: Doing Things Over and Over

Computers are extraordinary at repetition — they can do the same task a million times without getting bored or making a mistake. When you want to repeat an action, you use a loop. Imagine you need to display 100 messages in a chat: you would never copy-paste code 100 times. You write it once inside a loop.

The for Loop

The for loop is perfect when you know how many times you want to repeat. It has three parts packed into its brackets: a starting point, a condition to keep going, and a step that runs each round.

Reading it piece by piece:

• int i = 1 — the start: create a counter named i beginning at 1.
• i <= 5 — the condition: keep looping as long as this is true.
• i++ — the step: add 1 to i after each round (i++ is shorthand for i = i + 1).

So i becomes 1, 2, 3, 4, 5 — and when it reaches 6, the condition 6 <= 5 is false, so the loop stops. Elegant and precise.

The while Loop

Sometimes you do not know the exact number of repeats in advance — you just want to keep going until some condition changes. That is the while loop:

The for-in Loop — Going Through a List

The most common loop in real apps walks through a collection of items one by one. You will use this constantly to display lists of posts, products or messages:

We will meet Lists properly in the next lesson — but notice how naturally the loop reads: "for each fruit in fruits, print it."

Deep Dive: break and continue

You can control the flow inside a loop using two special keywords:

• break — immediately stops the entire loop, jumping out of it completely.
• continue — skips the rest of the current round and immediately jumps to the next round.

Animated Example

A for-loop counting 1 to 5

Play

1

2

3

4

5

Count: 1

Count: 2

Count: 3

Count: 4

Count: 5

1. i starts at 1. Condition 1 <= 5 is true → print "Count: 1".
2. i++ makes it 2. Still ≤ 5 → run again.
3. 3 — the loop keeps going, printing each round.
4. 4 — one more pass.
5. 5 is the last valid value. Next i is 6; 6 <= 5 is false, so the loop stops.

Functions: Package Your Logic

Imagine you have ten lines of code that calculate the total price of a shopping cart. If the user checks out from five different screens, you certainly do not want to copy those ten lines five times. Instead, you bundle them together, give them a name, and reuse them anywhere with a single word. That bundle is a function.

Defining and Calling a Function

Look closely at the definition. The int at the very front is the return type — it promises the function hands back a whole number. Inside the brackets, int item1, int item2 are the parameters — the inputs the factory needs. The return keyword sends the finished value back to whoever called it.

Functions That Return Nothing

Not every function produces a value; some just do something, like showing a message. Those use the return type void, which means "returns nothing":

The Short "Arrow" Syntax

When a function is just a single line, Dart offers a lovely shorthand using => (called the "fat arrow"). These two functions do exactly the same thing:

You will see the arrow form everywhere in Flutter, especially for button actions, so it is worth getting comfortable with now.

Named & Optional Parameters

When a function has many inputs, it can be hard to remember their order. Dart lets you use named parameters by wrapping them in curly braces { }. You can also make them optional or give them default values:

Anonymous Functions

Sometimes you need a function just once, right where you are typing. You don't need to give it a name. These are called anonymous functions or lambdas:

Notice the (item) { ... } part? That's a nameless function passed directly into another method.

Deep Dive: Functions as First-Class Citizens

In Dart, functions are "first-class citizens". This means you can treat a function exactly like a variable: you can pass a function as an argument to another function, return a function from a function, or assign a function to a variable.

This is incredibly powerful in Flutter, where you frequently pass functions (callbacks) to buttons to tell them what to do when pressed.

Deep Dive: Lexical Closures

A closure is a function object that has access to variables in its lexical scope, even when the function is used outside of its original scope. Simply put, a function "remembers" the environment in which it was created.

Closures allow you to create highly flexible factory functions and are extensively used when managing state and delayed executions.

Deep Dive: Tear-offs

If you have a function that takes the exact same arguments as the function you want to pass it to, you don't need to write a new anonymous function. You can just pass the function's name. This is called a tear-off and it makes Flutter UI code much cleaner.

Animated Example

Input → function → output

Play

5

10

add(a, b)
return a + b

?

1. We call the function with two inputs: add(5, 10).
2. Inside, the parameters become a = 5 and b = 10; it runs a + b.
3. It returns 15 — the output. Reuse it with any inputs, forever.

Organising Data: Lists, Maps & Classes

Real apps rarely deal with one value at a time. A chat has many messages; a store has many products; a profile bundles a name, age and photo together. Dart gives us structures to organise groups of data cleanly. This lesson rounds out your Dart foundation.

Lists — Ordered Collections

A List holds many values in order. Each item has a position number called an index — and, as in almost every language, counting starts at 0, not 1.

Lists power almost every scrolling screen you have ever used. The list of chats in WhatsApp, the feed in Instagram — all Lists of data being displayed one item at a time.

Maps — Labelled Data (Key & Value)

A Map stores values under named labels called keys, instead of numbered positions. It is perfect for describing one "thing" with several properties:

Maps matter enormously because data arriving from the internet almost always comes in this key-and-value shape (a format called JSON, which you will meet in Course 4).

Classes — Designing Your Own Types

A Map works, but for important data we usually build a class: a custom blueprint that defines exactly what a "thing" looks like. This is the doorway to a huge topic called Object-Oriented Programming, and you only need the gentle basics for now.

Sets — Unique Collections

A Set is like a List, but it guarantees that every item is unique. If you try to add a duplicate, it simply ignores it. Sets use curly braces:

Collection Superpowers: map and where

Dart collections have built-in methods that make manipulating data incredibly easy without writing manual loops:

• where() — filters a collection based on a condition.
• map() — transforms every item in a collection into something else.

Deep Dive: Advanced Collection Operations

Dart collections have powerful methods like fold and reduce to combine all elements into a single value. For example, summing up a list of numbers:

You can also quickly generate lists using List.generate:

Deep Dive: Spread Operator and Collection If/For

Dart provides incredibly elegant ways to build collections dynamically. The spread operator (...) unpacks a list into another list. Collection if and Collection for let you use logic directly inside a list declaration!

You will use these features heavily in Flutter to dynamically construct the Widget tree (the UI) based on your app's state.

Deep Dive: Equatable and Object Equality

In Dart, two objects are not equal even if their contents are identical, because they live in different memory addresses. User('Alex') == User('Alex') is false. When managing lists of data or app state (like in Bloc or Riverpod), you must override the == operator and hashCode so Dart knows how to compare them.

Professionals usually use the Equatable package to do this automatically instead of writing it by hand!

Animated Example

Lists hold order; Maps hold labels

Play

'Sara'

'Omar'

'Lina'

names[0] → 'Sara' · index starts at 0

Map username: 'Sara', age: 25

1. A List holds many values in order: ['Sara', 'Omar', 'Lina'].
2. Each has an index starting at 0 — so names[0] is 'Sara'.
3. A Map stores values under named keys instead — perfect for describing one thing.

Object-Oriented Programming (OOP)

We briefly met classes in the last lesson. Now we go properly deep, because Object-Oriented Programming — OOP for short — is the way nearly all professional apps are structured. The idea is elegant: instead of scattering data and logic everywhere, you model the real world as objects, each bundling its own data and its own actions together.

Properties and Methods

Inside a class, the data is stored in variables called properties, and the actions are written as functions called methods. Here is a complete, well-formed class:

A class bundles data (properties) and actions (methods) together.

The Constructor: Building an Object

The special line Dog(this.name, this.age); is the constructor. It is the recipe for creating a new dog: it says "to make a Dog, give me a name and an age, and store them." Once the class (the blueprint) exists, you create real objects from it:

Notice how rex and bella are independent objects, each with its own name and age, yet both built from the same Dog class. This is the whole point: one blueprint, unlimited objects.

Inheritance: Building on What Exists

Here is where OOP becomes truly powerful. Suppose you need a Puppy that is just like a Dog but with an extra action. Rather than rewriting everything, a Puppy can inherit from Dog using the extends keyword — it automatically gains all of Dog's properties and methods, and can add its own:

Abstract Classes — Setting the Rules

Sometimes you want to create a blueprint that is so generic it shouldn't be built directly. An abstract class defines the rules (methods and properties) that other classes must follow, but leaves the specific implementation to them:

Mixins — Adding Abilities

Inheritance lets you build on one class, but what if you want to add an ability to completely unrelated classes? Mixins let you "mix in" chunks of code wherever needed using the with keyword:

Deep Dive: Polymorphism & Interfaces

Polymorphism allows objects of different classes to be treated as objects of a common superclass. This is especially powerful with interfaces. In Dart, every class implicitly defines an interface. You use the implements keyword to force a class to follow a specific contract, meaning it MUST provide its own version of all the methods and properties.

Deep Dive: Static Members & Factory Constructors

Sometimes a property or method belongs to the class itself, not to any specific object. We use the static keyword for this:

A factory constructor gives you more control when creating objects. Unlike a normal constructor which always makes a new instance, a factory can return an existing instance from a cache, or a subclass.

Deep Dive: Enhanced Enums

An enum (enumeration) is a special type used to define a collection of constant values (like Days of the week or Loading states). Since Dart 2.17, enums have "superpowers" and can have their own properties, methods, and constructors, much like a class!

Deep Dive: Mixin Constraints (on)

Mixins are amazing, but sometimes a mixin requires the class it's applied to to have certain properties. You can restrict a mixin using the on keyword. This ensures the mixin can only be used on classes that extend a specific base class, allowing the mixin to safely call methods from that base class.

Animated Example

One blueprint, many objects

Play

class Dog
name, age
bark()

🐕 Rex · age 3

🐕 Bella · age 5

1. First we design the blueprint: a Dog class with name, age and bark().
2. From it we build a real object: Rex, age 3.
3. And another: Bella, age 5. One class — unlimited independent objects.

Writing Code That Doesn't Crash

This final Dart lesson is what separates code that works on your machine from code that survives real users doing unexpected things. Professionals do not just make apps work — they make apps that fail gracefully. Two Dart features make this possible: null safety and error handling.

The Billion-Dollar Problem: null

null means "no value at all — empty." It sounds harmless, but historically it has been the single biggest source of app crashes in the world. Imagine your code expects a user's name, but the name is null (perhaps they never entered it). Trying to use that empty value crashes the app.

Dart solves this with null safety: by default, a variable is not allowed to be null, so the mistake is caught while you write, not after you ship. If a value genuinely can be empty, you must say so explicitly with a ?:

Handling Possible Nulls Safely

When a value might be null, Dart gives you clean tools to handle it:

• ?? — provides a fallback: nickname ?? 'Guest' means "use nickname, or 'Guest' if it is null."
• ?. — safely accesses something only if it is not null, avoiding a crash.

The ?? operator turns a potential crash into a sensible default.

Catching Errors with try / catch

Some operations can fail for reasons outside your control: the internet drops, a file is missing, or a user types letters where a number was expected. Rather than letting the app crash, you wrap the risky code in a try block and handle any failure in a catch block:

Read the flow: Dart tries the risky line; if it fails, it jumps to catch and shows a friendly message instead of crashing; and finally always runs at the end for cleanup. Your user sees a calm "please try again," never a frozen or crashed screen.

Throwing Your Own Errors

You are not limited to catching system errors. You can (and should!) throw your own errors when someone tries to use your code incorrectly, using the throw keyword. This is called "failing fast":

Async Error Handling

When fetching data from the internet (which takes time), we use asynchronous programming. try / catch works perfectly there too, often combined with async and await:

Deep Dive: Custom Exceptions

For large apps, standard errors aren't descriptive enough. You can create your own exception classes by implementing the Exception interface. This makes your error handling much more specific and readable.

Deep Dive: Global Error Catching in Flutter

Even with perfect try/catch blocks, a bug might slip through. If an error is completely unhandled, a Flutter app normally shows a scary red screen of death. Professionals intercept these using FlutterError.onError and PlatformDispatcher to log the crash to services like Firebase Crashlytics and show a polite fallback screen instead.

Animated Example

try / catch turns a crash into a message

Play

int.parse('hello')

✗ crash (unhandled)

✓ caught → friendly message

1. A risky line — parsing "hello" as a number — fails. Unhandled, it would crash the whole app.
2. Wrapped in try/catch, the failure is caught and you show a calm "please try again" instead. Professionals plan for what goes wrong.

Asynchronous Programming

In the real world, many tasks take time: downloading an image, fetching data from a server, or reading a large file. If our app waits completely frozen for these tasks to finish, it feels broken. Asynchronous programming lets our code say, "Start this slow task, let me keep doing other things (like responding to user taps), and tell me when it's done."

Futures: A Promise of Data

In Dart, a Future represents a value that isn't ready yet, but will be in the future. Think of it like a restaurant receipt: you don't have your food immediately, but you hold a promise that you'll get it soon.

async and await

The cleanest way to handle a Future is using the async and await keywords. They allow you to write asynchronous code that looks just like normal, line-by-line code.

Streams: A Flow of Data

While a Future gives you exactly one value eventually, a Stream gives you a sequence of values over time. Think of it like a hose pipe of data. We use streams for things like location updates, chatting in real-time, or a countdown timer.

Deep Dive: StreamController

While async* is great for creating streams, sometimes you need to manually add events to a stream from different parts of your app (like when a user clicks a button). For this, we use a StreamController.

Deep Dive: Executing Futures in Parallel

What if you need to fetch the User's profile, their friends list, and their unread messages all at once? If you await them one by one, it takes a long time. Future.wait() allows you to run multiple asynchronous tasks simultaneously and wait for them all to finish together.

Deep Dive: The Completer

Sometimes you need to create a Future from scratch based on some old callback-based API, or you want to manually trigger when a Future is finished from completely different parts of your code. A Completer gives you the controls to a Future: you can return its future immediately, and later call complete() when you're ready.

Advanced Dart Features

To truly master Dart and write code like a professional, there are a few advanced tools that make your code cleaner, safer, and incredibly powerful. These features reduce repetition and allow for highly flexible structures.

Extensions: Adding Superpowers

What if you want a new method on String or int, but you didn't write those classes? Extensions let you add new methods to existing classes without touching their original code.

Generics: Flexible Types

Sometimes you want a class or function to work with any type, while still keeping Dart's type safety. This is what Generics (the <T> syntax) are for. You've already used them with List<String>!

Isolates: Heavy Lifting

Even with async, Dart runs on a single thread. If you do something incredibly heavy (like processing a huge image or complex encryption), the app will stutter. Isolates allow you to run heavy tasks on a completely separate processor core.

Dart 3 Magic: Records and Pattern Matching

With Dart 3, you can return multiple values from a function cleanly using Records, and use Pattern Matching to easily destructure and check data shapes. This completely modernizes how you write Dart.

Deep Dive: Sealed Classes (Dart 3)

Dart 3 introduced class modifiers, the most prominent being the sealed class. A sealed class allows you to define a strictly closed set of subtypes. The compiler knows all possible subclasses, meaning a switch statement over a sealed class can be exhaustively checked (if you miss a case, it throws an error!).

This pattern is arguably the most robust way to manage UI state in modern Flutter applications.

Deep Dive: Extension Types (Dart 3.3)

Dart 3.3 introduced Extension Types. They look like wrappers around existing types (like an `int` or a `String`), adding specific methods to them, but they exist only at compile-time. This means zero performance cost or memory overhead at runtime! It's perfect for things like typed IDs.

At runtime, Dart erases `UserId` completely and treats it just like a raw `int`, making it incredibly fast.

Design Patterns in Dart

As you build larger apps, you'll encounter the same structural problems repeatedly. Design Patterns are proven, standardized solutions to these common problems. They make your code more modular, testable, and easier for other developers to understand.

The Singleton Pattern

Sometimes you want a class to have exactly one instance throughout the entire lifecycle of your app (like a Database connection or an Authentication service). The Singleton pattern guarantees this.

The Factory Pattern

When you have a superclass and multiple subclasses, and you want to delegate the responsibility of which subclass to instantiate to a special method, you use the Factory pattern.

The Observer Pattern (Streams)

The Observer pattern is used when you want an object to notify other objects about changes in its state. In Dart, this is elegantly built-in using Streams and StreamController. It's the foundation of Reactive Programming.

The Repository Pattern

As your app grows, you might fetch data from a local database, an API, or a cache. The UI shouldn't care where the data comes from. The Repository Pattern creates a clean boundary: the UI asks the Repository for data, and the Repository decides whether to fetch it from the API or local storage.

This pattern is essential for offline-first applications and makes your code incredibly easy to test, as you can easily mock the database or API.

Memory Management & Performance

Professional developers don't just write code that works; they write code that is efficient. Dart uses a Garbage Collector to manage memory, but poorly written code can still cause memory leaks and stuttering interfaces.

Understanding the Garbage Collector

Dart periodically scans your app's memory to find objects that are no longer being used (objects that have no references pointing to them). When it finds them, it automatically deletes them to free up RAM. This is called Garbage Collection (GC).

However, if you accidentally keep a reference to an object, the GC cannot delete it. This is a Memory Leak.

Common Memory Leak: Forgetting to Dispose

The most common cause of memory leaks in Dart and Flutter is forgetting to close Streams, Timers, or Controllers. If a Stream keeps listening forever, the object holding it can never be garbage collected.

Constant Objects (const)

Every time you create an object, it takes up memory. If an object's properties never change, you can declare its constructor as const. Dart will create it exactly once in memory and reuse that exact same instance everywhere in your app, drastically improving performance.

Deep Dive: Isolates vs Async

Remember that async/await does NOT run code in parallel. It just pauses a function to let the single main thread do other things. If you do heavy math inside an async function, the main thread will still freeze, causing your app's animations to stutter (UI jank).

For heavy computation (like parsing a massive JSON file or applying an image filter), you MUST use Isolate.run() (introduced in Dart 2.19). It moves the work to a background CPU thread entirely.