App Development with Swift study plan

Declare constants and variables across Int, Double, String, Bool, and tuples, writing down the inferred type before compiling each line.

Write branching logic with if, guard, and switch, including range matching and where clauses, and rewrite two if-chains as switches.

Implement for-in, while, and repeat-while loops that build and filter a 20-item in-memory dataset without using higher-order functions.

Trace and repair 10 deliberately broken snippets covering integer overflow, string interpolation, and operator precedence.

Write functions with argument labels, default parameters, variadic parameters, and inout parameters, then justify each choice in a comment.

Convert three named functions into closure expressions using shorthand argument names and trailing-closure syntax.

Distinguish escaping from non-escaping closures by storing one for later execution and proving capture behaviour with a test.

Implement map, filter, reduce, compactMap, and sorted over a string array, replacing five hand-written loops.

Explain capture lists and strong reference cycles in a closure with a two-object demo that you run and observe.

Build five structs and three classes modelling a library lending system, choosing value or reference semantics deliberately for each type.

Implement designated, convenience, and failable initializers, and justify in a comment why each initializer exists.

Demonstrate copy-on-assignment for structs and shared mutation for classes with paired tests that would fail under the wrong semantics.

Add computed properties, property observers, and lazy properties to the model and test each one's behaviour.

Diagram ARC ownership for the class graph, then break one retain cycle with weak and confirm the deinit fires.

Replace every stringly-typed constant with an enum using raw values, associated values, and CaseIterable.

Define three protocols, conform existing types to them, and add default implementations in protocol extensions.

Write one generic function constrained to a protocol and refactor two duplicated concrete functions into it.

Drive a multi-step workflow from an enum with associated values and switch over it exhaustively.

Select between Array, Set, and Dictionary for five stated scenarios and record the Big-O justification for each in a comment.

Sort, group, and deduplicate a 500-item dataset using only higher-order functions.

Rewrite 10 forced-unwrap sites as optional binding, optional chaining, or nil-coalescing, and note what each rewrite makes safer.

Write tests proving collection copy semantics and that index access stays in bounds after mutation.

Define a custom Error enum with four cases and throw it from a validating initializer.

Wrap throwing calls in do/catch with case-specific recovery, and use defer to guarantee cleanup.

Convert a callback-plus-optional-return API into one returning Result, then compare the two call sites side by side.

Apply guard-let at function boundaries and demonstrate early exit for each documented failure mode.

Compose three screens (list, detail, form) with NavigationStack, passing data through initializers instead of globals.

Manage state with @State, @Binding, and an observable model type, documenting which object owns the source of truth.

Extract view models so the view files contain no business logic, and unit-test each view model in isolation.

Render loading, empty, and error states for the list screen from a single state enum.

Apply MVVM with dependency injection through protocol-typed constructor parameters, then swap in a fake service during tests.

Write unit tests for the view models and one UI test covering the app's primary navigation flow.

Refactor one screen to remove a singleton and record how many previously untestable paths became testable.

Complete two timed 50-question mixed practice sets and log every error by domain.