Swift Roadmap

Open a topic for notes and resources. Mark it done when you are ready to move on.

26 stages · 103 topics 0% done
Swift
✓ Generic Functions & Type Parameters
✓ Associated Types & Protocol Generics
✓ Foundations
✓ Opaque Types (some)
✓ Existential Types (any)
✓ Core Concepts
✓ Conditional Conformance
✓ Phantom Types for Type Safety
✓ Generic Subscripts & Extensions
✓ Closure Expression Syntax
✓ Intermediate Skills
✓ Trailing Closure & Operator Methods
✓ Capturing Values & Capture Lists
✓ Advanced Topics
✓ @escaping & @autoclosure
✓ Closure Lifetime & Strong Reference Cycles
✓ Closure in Result Builders
✓ Function vs Closure Performance
✓ Expert Level
✓ async/await (Swift 5.5)
✓ Task & TaskGroup
✓ Mastery
✓ Actor Isolation & reentrancy
✓ @MainActor & Global Actors
✓ AsyncSequence & AsyncStream
✓ Continuations (withCheckedContinuation)
✓ Ecosystem
✓ Structured Concurrency Patterns
✓ ARC (Automatic Reference Counting)
✓ Architecture
✓ Strong, Weak, Unowned References
✓ Retain Cycle Detection
✓ Autoreleasepool
✓ Value Semantics & Copy-on-Write
✓ Optimization
✓ COW Implementation for Custom Types
✓ Memory Allocation (malloc, class_getInstanceSize)
✓ Deployment
✓ Property Wrapper Definition
✓ projectedValue ($ prefix)
✓ Built-in Wrappers (@State, @Binding, @Published)
✓ Custom Validation Wrappers
✓ Phase 11
✓ Dependency Injection Wrappers
✓ UserDefaults Wrapper
✓ Phase 12
✓ Property Wrapper Composition
✓ Result Builder Protocol (buildBlock, buildEither)
✓ buildArray for Dynamic Content
✓ buildOptional & If/Else
✓ Phase 13
✓ AttributedResultBuilder (SwiftUI ViewBuilder)
✓ Custom Result Builder for DSLs
✓ Phase 14
✓ Result Builder Debugging
✓ Performance Considerations
✓ Freestanding Macros (#)
✓ Attached Macros (@)
✓ Phase 15
✓ Macro Declaration & Implementation
✓ SwiftSyntax & Macro Expansion
✓ Phase 16
✓ Peer & Member Macros
✓ Macro Roles & Common Patterns
✓ Debugging Macros
✓ Codable Protocol Hierarchy
✓ Phase 17
✓ CodingKey & Custom Key Strategies
✓ Custom encode(to:)/init(from:)
✓ Phase 18
✓ JSONEncoder/Decoder Configuration
✓ Partial & Conditional Decoding
✓ Property Wrapper + Codable
✓ Performance of Codable vs Manual
✓ Phase 19
✓ View Protocol & Body
✓ State Management (State, Binding, ObservedObject)
✓ Phase 20
✓ @StateObject vs @ObservedObject
✓ PreferenceKey
✓ GeometryReader & Layout
✓ EquatableView & Performance
✓ Phase 21
✓ Custom Layout (Layout Protocol)
✓ Publisher, Subscriber, Subscription
✓ Phase 22
✓ Operators (map, flatMap, filter, merge)
✓ Scheduler (DispatchQueue, RunLoop)
✓ Subjects (Passthrough, CurrentValue)
✓ Cancellation & Share
✓ Phase 23
✓ Combine + SwiftUI Integration
✓ Custom Publisher Implementation
✓ Phase 24
✓ XCTest Framework
✓ Async Test Expectations
✓ UI Testing (XCUITest)
✓ Mocking with Protocols
✓ Phase 25
✓ Performance Testing (measure)
✓ Test Coverage (llvm-cov)
✓ Phase 26
✓ Snapshot Testing (swift-snapshot-testing)
Text version of this roadmap

1. Foundations

  • Generic Functions & Type Parameters
  • Associated Types & Protocol Generics
  • Opaque Types (some)

2. Core Concepts

  • Existential Types (any)
  • Conditional Conformance
  • Phantom Types for Type Safety

3. Intermediate Skills

  • Generic Subscripts & Extensions
  • Closure Expression Syntax
  • Trailing Closure & Operator Methods

4. Advanced Topics

  • Capturing Values & Capture Lists
  • @escaping & @autoclosure
  • Closure Lifetime & Strong Reference Cycles

5. Expert Level

  • Closure in Result Builders
  • Function vs Closure Performance: Performance considerations for function vs closure performance in Swift significantly impact application behavior. Understanding optimization strategies helps avoid common pitfalls and improve runtime characteristics.
  • async/await (Swift 5.5)

6. Mastery

  • Task & TaskGroup
  • Actor Isolation & reentrancy
  • @MainActor & Global Actors

7. Ecosystem

  • AsyncSequence & AsyncStream
  • Continuations (withCheckedContinuation)
  • Structured Concurrency Patterns: Various async/await & actors patterns emerge when working with structured concurrency patterns in Swift. These patterns provide reusable solutions to common programming challenges.

8. Architecture

  • ARC (Automatic Reference Counting)
  • Strong, Weak, Unowned References
  • Retain Cycle Detection

9. Optimization

  • Autoreleasepool
  • Value Semantics & Copy-on-Write
  • COW Implementation for Custom Types: The cow implementation for custom types pattern in Swift provides a structured approach to handling ARC & Memory. Understanding the implementation details helps write more robust and maintainable code.

10. Deployment

  • Memory Allocation (malloc, class_getInstanceSize)
  • Property Wrapper Definition
  • projectedValue ($ prefix)

11. Phase 11

  • Built-in Wrappers (@State, @Binding, @Published)
  • Custom Validation Wrappers
  • Dependency Injection Wrappers

12. Phase 12

  • UserDefaults Wrapper
  • Property Wrapper Composition
  • Result Builder Protocol (buildBlock, buildEither)

13. Phase 13

  • buildArray for Dynamic Content
  • buildOptional & If/Else
  • AttributedResultBuilder (SwiftUI ViewBuilder)

14. Phase 14

  • Custom Result Builder for DSLs
  • Result Builder Debugging
  • Performance Considerations: Performance considerations for performance considerations in Swift significantly impact application behavior. Understanding optimization strategies helps avoid common pitfalls and improve runtime characteristics.

15. Phase 15

  • Freestanding Macros (#)
  • Attached Macros (@)
  • Macro Declaration & Implementation: The macro declaration & implementation pattern in Swift provides a structured approach to handling Macros. Understanding the implementation details helps write more robust and maintainable code.

16. Phase 16

  • SwiftSyntax & Macro Expansion
  • Peer & Member Macros
  • Macro Roles & Common Patterns: Various macros patterns emerge when working with macro roles & common patterns in Swift. These patterns provide reusable solutions to common programming challenges.

17. Phase 17

  • Debugging Macros
  • Codable Protocol Hierarchy
  • CodingKey & Custom Key Strategies

18. Phase 18

  • Custom encode(to:)/init(from:)
  • JSONEncoder/Decoder Configuration
  • Partial & Conditional Decoding

19. Phase 19

  • Property Wrapper + Codable
  • Performance of Codable vs Manual: Performance considerations for performance of codable vs manual in Swift significantly impact application behavior. Understanding optimization strategies helps avoid common pitfalls and improve runtime characteristics.
  • View Protocol & Body

20. Phase 20

  • State Management (State, Binding, ObservedObject)
  • @StateObject vs @ObservedObject
  • PreferenceKey

21. Phase 21

  • GeometryReader & Layout
  • EquatableView & Performance: Performance considerations for equatableview & performance in Swift significantly impact application behavior. Understanding optimization strategies helps avoid common pitfalls and improve runtime characteristics.
  • Custom Layout (Layout Protocol)

22. Phase 22

  • Publisher, Subscriber, Subscription
  • Operators (map, flatMap, filter, merge)
  • Scheduler (DispatchQueue, RunLoop)

23. Phase 23

  • Subjects (Passthrough, CurrentValue)
  • Cancellation & Share
  • Combine + SwiftUI Integration

24. Phase 24

  • Custom Publisher Implementation: The custom publisher implementation pattern in Swift provides a structured approach to handling Combine Framework. Understanding the implementation details helps write more robust and maintainable code.
  • XCTest Framework
  • Async Test Expectations

25. Phase 25

  • UI Testing (XCUITest)
  • Mocking with Protocols
  • Performance Testing (measure): Performance considerations for performance testing (measure) in Swift significantly impact application behavior. Understanding optimization strategies helps avoid common pitfalls and improve runtime characteristics.

26. Phase 26

  • Test Coverage (llvm-cov)
  • Snapshot Testing (swift-snapshot-testing)