Swift Intermediate → Advanced ~12 weeks

Swift: From Intermediate to Advanced

Concurrency is what separates intermediate Swift from advanced Swift now, and the shift is genuine rather than cosmetic. Actors, structured tasks and Sendable are the compiler taking responsibility for data races that were previously yours to avoid by discipline, which is a better deal - but only once you understand what the isolation rules are actually enforcing.

Generate my free course

Free to start · no credit card · the outline below is an example, yours is generated around your goals

What this path covers

  • async/await and structured tasks
  • Actors and isolation
  • Sendable and data races
  • ARC and memory
  • Performance profiling
  • Advanced generics

Sample curriculum

An example outline for going from intermediate to advanced in Swift. Your generated course adapts this to your experience, target level and available study time.

  1. Structured Concurrency

    async and await as a compiler transformation, task groups, cancellation that propagates, and async sequences for values arriving over time.

  2. Actors and Isolation

    Actors as serialised state, actor isolation and the await that crossing it requires, MainActor for UI work, and reentrancy - the surprise that catches most people once.

  3. Sendable and Data Race Safety

    What Sendable promises, why the compiler rejects captures you used to write freely, migrating an existing codebase incrementally, and reading strict concurrency diagnostics.

  4. ARC and Memory in Depth

    How retain and release actually work, strong, weak and unowned with the trade-off each makes, diagnosing leaks and retain cycles in Instruments.

  5. Performance Work

    Value semantics and copy-on-write, existential containers and why protocol types can cost, reducing allocations, and measuring with Instruments before changing anything.

  6. Generics at the Edges

    Opaque return types with some, existential any and what changed, generic constraints that keep call sites readable, and result builders as they appear in SwiftUI.

Swift intermediate-to-advanced questions

What problem do actors actually solve?

Concurrent access to mutable state. An actor serialises access to its own storage, so two tasks cannot mutate it simultaneously - the compiler enforces what previously depended on remembering to use a queue.

weak or unowned?

weak when the reference can legitimately become nil and you will handle that; unowned when it cannot outlive the owner and a nil would be a programming error. Unowned avoids the optional but crashes if you are wrong about the lifetime.

Is strict concurrency checking worth enabling on an existing app?

Yes, incrementally - module by module rather than all at once. It surfaces real races that were previously invisible, but enabling it project-wide on a large codebase produces a volume of diagnostics that is hard to act on.

Where to go next

Start from the beginning in Swift Swift: From Beginner to Intermediate Another Swift path Swift: From Beginner to Advanced Next step in Swift Swift: From Absolute Beginner to Job Ready Same level in PHP PHP: From Intermediate to Advanced Same level in Ruby Ruby: From Intermediate to Advanced

Ready to start Swift?

Swift is the language for anything running on Apple hardware. Tell LearnForge where you are now and where you want to get to, and it builds the course around that.

Generate my free course