Work with numbers, text, Booleans, string interpolation, and common operators. You will practice turning everyday facts into precise Swift expressions.

Use if, switch, ranges, loops, and pattern matching to choose what code runs next. You will write programs that handle different cases instead of following one fixed path.

Create functions with parameters, return values, default arguments, labels, and clean names. You will turn repeated steps into reusable pieces of code.

Store many values with arrays, dictionaries, and sets, then add, remove, search, sort, and loop through them. You will use collections to model lists, lookup tables, and unique groups.

See how Swift grew from Apple’s Objective-C era into an open-source language used for apps, servers, tools, and systems work. The timeline explains why Swift values safety, performance, protocols, and clear APIs.

Use optionals, nil, optional binding, guard, optional chaining, and nil coalescing to handle missing values safely. You will stop guessing whether data exists and make that choice visible in code.

Create structs and enums to represent real concepts such as users, orders, screens, and states. You will model data so invalid combinations become harder to create.

Add methods, computed properties, property observers, and initializers to your own types. Your data models will start carrying useful behavior instead of being plain containers.

Use protocols to describe abilities that many types can share, then add default behavior with protocol extensions. You will write code that depends on what a type can do, not on one exact type.

Write generic functions and types that work with many kinds of data while staying type-safe. You will build reusable code without giving up Swift’s compiler checks.

Use throwing functions, do-catch, Result, defer, and custom error types to report and recover from failure. You will decide which problems can be handled, retried, logged, or shown to a user.

Use closures, higher-order functions, capture lists, map, filter, reduce, and sorted to pass behavior around. You will make collection code shorter while still keeping it readable.

Compare value types and reference types, copy-on-write behavior, identity, mutation, and when each choice matters. You will know why Swift often favors structs but still uses classes in the right places.

Use classes, inheritance, overriding, final, required initializers, and deinitializers where reference identity is needed. You will also recognize when inheritance adds risk and when composition is cleaner.

Manage memory with ARC, strong and weak references, unowned references, and capture lists. You will prevent common leaks in object graphs and closure-heavy code.

Split code into files, modules, targets, and access levels such as public, internal, and private. You will shape APIs that are pleasant to use and hard to misuse.

Create packages, define products and targets, add dependencies, and use semantic versioning with Swift Package Manager. You will build code that other projects can reuse.

Write unit tests, async tests, test fixtures, and readable assertions with XCTest and Swift Testing. You will catch broken behavior before it reaches users or teammates.

Use breakpoints, the LLDB console, logging, Instruments, and compiler diagnostics to find bugs and slow code. You will move from guessing to evidence-based debugging.

Read and write files, encode and decode JSON with Codable, validate data, and handle dates and URLs. You will connect Swift types to the outside world cleanly.

Make HTTP requests, decode responses, handle status codes, retry failures, and separate networking code from app logic. You will build clients that talk to real web services.

Use async, await, Task, task groups, cancellation, and async sequences to write code that waits without freezing. You will make network, file, and background work easier to read and maintain.

Use actors, MainActor, Sendable, isolation, and structured concurrency rules to protect shared state. You will recognize and fix data races before they become rare, hard-to-repeat bugs.

Handle streams of values over time with AsyncSequence and Combine where it still appears in Apple codebases. You will manage search text, notifications, timers, and long-running updates without tangled callbacks.

Build interfaces with SwiftUI views, modifiers, layouts, navigation, forms, lists, and previews. You will turn Swift data models into screens that update as state changes.

Use @State, @Binding, @Observable, environment values, and view models to keep SwiftUI screens in sync with app data. You will decide where state belongs and avoid confusing update loops.

Store user data with UserDefaults, files, SQLite-shaped thinking, Core Data, and SwiftData. You will choose a persistence approach based on data size, relationships, syncing needs, and migration risk.

Call Objective-C, C, and C++ code from Swift, expose Swift APIs safely, and work with Apple frameworks that still carry older patterns. You will be ready for real codebases that mix generations of technology.

Measure allocations, reduce unnecessary copies, use lazy work, choose efficient collections, and read performance traces. You will improve speed and memory use without guessing or over-optimizing.

Use Swift macros to generate repeated code while keeping call sites clear. You will know when macros help, when a normal function or protocol is better, and how generated code affects debugging.

Protect tokens, user data, network traffic, local storage, and permissions in Swift apps and services. You will make safer choices around Keychain, HTTPS, input validation, privacy prompts, and logging.

Design, build, test, package, and document a command-line Swift tool from a real user request. This workflow ties together arguments, file handling, errors, tests, releases, and versioned packages.

Plan a small SwiftUI app, model its data, connect an API, store local state, test key behavior, and prepare it for distribution. You will practice the decisions a developer makes from first sketch to working app.

Build REST APIs and background services with server-side Swift tools such as Vapor, Codable, async database access, and structured logging. You will see where Swift fits outside Apple apps.

Use GitHub Actions or similar tools to test Swift packages, build apps, run linters, sign releases, and manage dependency updates. You will create repeatable builds instead of relying on one developer’s machine.

Use code completion, documentation lookup, refactoring tools, and AI coding assistants while still checking correctness yourself. You will treat generated suggestions as drafts that need tests, review, and security judgment.

Map Swift roles across iOS, macOS, watchOS, visionOS, server-side work, tooling, and open source. You will plan proof-of-skill projects, portfolio pieces, Apple Developer Program needs, interview practice, and ways to stay current through Swift Evolution and community resources.