Skip to main content

Learning path

Swift & iOS Development learning path: everything to study, topic by topic

Comprehensive Swift and iOS assessment covering language fundamentals, object-oriented and protocol-oriented programming, SwiftUI and UIKit, concurrency with async/await and actors, data persistence, networking, app architecture patterns, testing, and app distribution.

Short answer

To learn Swift & iOS Development, work through 6 modules and 24 topics in the order they build on each other. It starts with Swift Fundamentals, then moves on to OOP & Protocols and SwiftUI & UIKit. Use the map as a checklist, or measure your level and study only what is missing.

6
modules
24
topics
45
min to assess

What you will study

Topics are grouped by module. Open one to see its objectives and key concepts.

1 · Swift Fundamentals4 topics
  • Variables & Types

    Let and var declarations, type inference, basic types (Int, Double, String, Bool), type aliases, tuples, type safety, and type casting with as/is operators

    Objectives

    • Declare constants and variables with proper type annotations
    • Understand Swift's type safety and type inference system

    Key concepts

    • let vs var
    • type inference
    • Int, Double, String, Bool
    • type aliases
    • tuples
    • type safety
    • as/is operators
    • Any and AnyObject
  • Control Flow

    If/else, switch statements with pattern matching, for-in loops, while and repeat-while, guard statements, labeled statements, fallthrough, and where clauses

    Objectives

    • Write idiomatic Swift control flow with guard and switch
    • Use pattern matching in switch statements effectively

    Key concepts

    • if/else statements
    • switch with pattern matching
    • for-in loops
    • while and repeat-while
    • guard statements
    • labeled statements
    • fallthrough keyword
    • where clauses
  • Functions & Closures

    Function signatures with argument labels, default parameters, variadic parameters, inout parameters, closures, trailing closure syntax, capturing values, and @escaping

    Objectives

    • Write functions with proper argument labels and parameter types
    • Understand closure capture semantics and escaping closures

    Key concepts

    • argument labels
    • default parameters
    • variadic parameters
    • inout parameters
    • closure syntax
    • trailing closures
    • capturing values
    • @escaping closures
  • Optionals

    Optional types, optional binding (if let, guard let), nil coalescing operator, optional chaining, force unwrapping, implicitly unwrapped optionals, and map/flatMap on optionals

    Objectives

    • Safely unwrap optionals using binding and chaining
    • Avoid force unwrapping in production code

    Key concepts

    • Optional type
    • if let binding
    • guard let binding
    • nil coalescing (??)
    • optional chaining
    • force unwrapping (!)
    • implicitly unwrapped optionals
    • map/flatMap on Optional
2 · OOP & Protocols4 topics
  • Classes & Structs

    Value types vs reference types, memberwise initializers, designated and convenience initializers, inheritance, deinit, ARC basics, identity operators (===), and copy-on-write

    Objectives

    • Choose between structs and classes based on value/reference semantics
    • Implement proper initialization chains

    Key concepts

    • value types vs reference types
    • memberwise initializers
    • designated initializers
    • convenience initializers
    • inheritance
    • ARC basics
    • identity operators (===)
    • copy-on-write
  • Protocols

    Protocol definition, protocol conformance, protocol inheritance, protocol composition, associated types, protocol extensions with default implementations, and Equatable/Hashable/Codable

    Objectives

    • Design protocols with associated types and default implementations
    • Apply protocol-oriented programming patterns

    Key concepts

    • protocol definition
    • protocol conformance
    • protocol inheritance
    • protocol composition (&)
    • associated types
    • protocol extensions
    • default implementations
    • Equatable/Hashable/Codable
  • Extensions & Generics

    Type extensions, computed properties in extensions, conditional conformance, generic types and functions, type constraints, where clauses, and opaque types (some)

    Objectives

    • Write generic code with proper type constraints
    • Use extensions to organize and add functionality

    Key concepts

    • type extensions
    • computed properties in extensions
    • conditional conformance
    • generic functions
    • generic types
    • type constraints
    • where clauses
    • opaque types (some)
  • Enums & Pattern Matching

    Enum cases with associated values, raw values, CaseIterable, recursive enums, pattern matching with switch/if case/guard case, and enum with methods and computed properties

    Objectives

    • Design enums with associated values for domain modeling
    • Apply pattern matching to extract associated values

    Key concepts

    • associated values
    • raw values
    • CaseIterable
    • recursive enums (indirect)
    • if case let
    • guard case let
    • switch exhaustiveness
    • enum methods
3 · SwiftUI & UIKit4 topics
  • SwiftUI Basics

    View protocol, body property, VStack/HStack/ZStack, Text/Image/Button views, modifiers, @ViewBuilder, previews, and composing views

    Objectives

    • Build declarative UIs with SwiftUI view composition
    • Apply modifiers correctly to customize views

    Key concepts

    • View protocol
    • body property
    • VStack/HStack/ZStack
    • Text/Image/Button
    • view modifiers
    • @ViewBuilder
    • previews
    • view composition
  • SwiftUI State Management

    @State, @Binding, @ObservedObject, @StateObject, @EnvironmentObject, @Environment, Observable macro (@Observable), and data flow in SwiftUI

    Objectives

    • Choose the correct property wrapper for each data flow scenario
    • Manage state effectively across view hierarchies

    Key concepts

    • @State
    • @Binding
    • @ObservedObject
    • @StateObject
    • @EnvironmentObject
    • @Environment
    • @Observable macro
    • data flow patterns
  • UIKit Fundamentals

    UIViewController lifecycle, UIView hierarchy, Auto Layout constraints, UITableView/UICollectionView, delegation pattern, and Interface Builder vs programmatic UI

    Objectives

    • Implement UIKit views with Auto Layout constraints
    • Understand the UIViewController lifecycle methods

    Key concepts

    • UIViewController lifecycle
    • UIView hierarchy
    • Auto Layout
    • UITableView
    • UICollectionView
    • delegation pattern
    • programmatic UI
    • Interface Builder
  • Navigation & Routing

    NavigationStack (SwiftUI), NavigationPath, UINavigationController (UIKit), tab-based navigation, modal presentation, deep linking, and coordinator pattern

    Objectives

    • Implement navigation flows in both SwiftUI and UIKit
    • Design deep linking and routing strategies

    Key concepts

    • NavigationStack
    • NavigationPath
    • UINavigationController
    • tab-based navigation
    • modal presentation
    • deep linking
    • coordinator pattern
    • programmatic navigation
4 · Concurrency4 topics
  • Async/Await

    Async functions, await keyword, Task and TaskGroup, structured concurrency, async let bindings, continuation APIs, and AsyncSequence/AsyncStream

    Objectives

    • Write structured concurrent code with async/await
    • Bridge callback-based APIs to async/await using continuations

    Key concepts

    • async functions
    • await keyword
    • Task
    • TaskGroup
    • structured concurrency
    • async let
    • withCheckedContinuation
    • AsyncSequence
  • Actors

    Actor model, actor isolation, nonisolated keyword, @MainActor, global actors, Sendable protocol, @Sendable closures, and actor reentrancy

    Objectives

    • Design thread-safe types using actors
    • Understand actor isolation and Sendable constraints

    Key concepts

    • actor keyword
    • actor isolation
    • nonisolated
    • @MainActor
    • global actors
    • Sendable protocol
    • @Sendable closures
    • actor reentrancy
  • GCD & Operations

    DispatchQueue (serial, concurrent, main), DispatchGroup, DispatchSemaphore, OperationQueue, Operation subclassing, quality of service, and thread safety with locks

    Objectives

    • Manage concurrent work with GCD queues and groups
    • Choose appropriate dispatch patterns for different scenarios

    Key concepts

    • DispatchQueue
    • serial vs concurrent
    • main queue
    • DispatchGroup
    • DispatchSemaphore
    • OperationQueue
    • quality of service (QoS)
    • thread safety
  • Combine Framework

    Publisher and Subscriber protocols, operators (map, filter, flatMap, combineLatest), Subjects (PassthroughSubject, CurrentValueSubject), @Published, cancellables, and error handling

    Objectives

    • Build reactive data pipelines with Combine operators
    • Manage subscriptions and memory with cancellables

    Key concepts

    • Publisher protocol
    • Subscriber protocol
    • map/filter/flatMap
    • combineLatest/merge/zip
    • PassthroughSubject
    • CurrentValueSubject
    • @Published
    • AnyCancellable
5 · Data & Networking4 topics
  • Core Data

    NSManagedObject, NSPersistentContainer, NSFetchRequest, predicates, relationships, migrations, NSFetchedResultsController, and background contexts

    Objectives

    • Design Core Data models with relationships and migrations
    • Perform thread-safe operations with background contexts

    Key concepts

    • NSManagedObject
    • NSPersistentContainer
    • NSFetchRequest
    • NSPredicate
    • relationships
    • migrations
    • NSFetchedResultsController
    • background contexts
  • Networking & URLSession

    URLSession configuration, URLRequest, data/upload/download tasks, authentication challenges, background sessions, caching policies, and URL components

    Objectives

    • Build robust networking layers with URLSession
    • Handle authentication and background transfers

    Key concepts

    • URLSession
    • URLRequest
    • data tasks
    • upload/download tasks
    • authentication challenges
    • background sessions
    • URLCache
    • URLComponents
  • Codable & JSON

    Codable protocol (Encodable/Decodable), JSONEncoder/JSONDecoder, coding keys, custom encoding/decoding, nested containers, date strategies, and PropertyListEncoder

    Objectives

    • Implement Codable conformance for complex data models
    • Handle custom JSON structures with coding keys and containers

    Key concepts

    • Codable protocol
    • JSONEncoder
    • JSONDecoder
    • CodingKeys
    • custom encode/decode
    • nested containers
    • date decoding strategies
    • PropertyListEncoder
  • SwiftData

    @Model macro, ModelContainer, ModelContext, @Query macro, relationships, sorting and filtering, migration strategies, and CloudKit integration

    Objectives

    • Design data models with SwiftData and @Model macro
    • Integrate SwiftData with SwiftUI using @Query

    Key concepts

    • @Model macro
    • ModelContainer
    • ModelContext
    • @Query macro
    • relationships
    • sorting and filtering
    • migration strategies
    • CloudKit integration
6 · Advanced iOS4 topics
  • App Architecture

    MVC, MVVM, MVP, VIPER, TCA (The Composable Architecture), dependency injection, coordinator pattern, clean architecture, and modularization strategies

    Objectives

    • Evaluate and apply architecture patterns for iOS apps
    • Design modular and testable app architectures

    Key concepts

    • MVC pattern
    • MVVM pattern
    • dependency injection
    • coordinator pattern
    • clean architecture
    • modularization
    • TCA
    • unidirectional data flow
  • Testing

    XCTest framework, Swift Testing (@Test, #expect), unit tests, UI tests with XCUITest, mocking with protocols, test doubles, code coverage, and snapshot testing

    Objectives

    • Write effective unit and UI tests for iOS applications
    • Design testable code using dependency injection and protocols

    Key concepts

    • XCTest
    • Swift Testing (@Test, #expect)
    • unit tests
    • XCUITest
    • mocking with protocols
    • test doubles
    • code coverage
    • snapshot testing
  • Performance Optimization

    Instruments profiling, memory leaks and retain cycles, lazy loading, image caching, list performance, render loop optimization, and Energy Impact diagnostics

    Objectives

    • Profile and diagnose performance issues with Instruments
    • Prevent and fix memory leaks and retain cycles

    Key concepts

    • Instruments profiling
    • memory leaks
    • retain cycles
    • lazy loading
    • image caching
    • list performance
    • render loop
    • Energy Impact
  • App Distribution

    App Store Connect, provisioning profiles, code signing, TestFlight, CI/CD pipelines with Xcode Cloud, App Store Review guidelines, and enterprise distribution

    Objectives

    • Configure code signing and provisioning for distribution
    • Set up CI/CD pipelines for automated testing and deployment

    Key concepts

    • App Store Connect
    • provisioning profiles
    • code signing
    • TestFlight
    • Xcode Cloud
    • App Store Review guidelines
    • enterprise distribution
    • CI/CD pipelines

Levels: Junior, Mid, and Senior

Explain it in your own words

Graded by AI · no account · 1 question

No options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.

0 / 600

Already studying Swift & iOS Development?

The assessment measures topic by topic, and your plan skips what you already know.

Measure my level

Open to read. An account is only needed to be measured.

Frequently asked questions

Where should I start studying Swift & iOS Development?

Start with Swift Fundamentals: Variables & Types, Control Flow, and Functions & Closures. The map orders topics by what they depend on, so each one prepares the next.

How long does a full Swift & iOS Development assessment take?

A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.

Do I need an account to use this page?

No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.