Swift and iOS development: a reading path for app builders
This curriculum takes you from zero Swift knowledge to shipping polished, production-ready iOS apps. Each stage builds directly on the last — starting with the Swift language itself, moving through UIKit and SwiftUI fundamentals, then tackling architecture and real-world app quality before finally covering the App Store submission process and professional best practices.
iOS Fundamentals with UIKit
BeginnerBuild real iOS apps using UIKit — understanding view controllers, Auto Layout, table views, navigation, and the MVC pattern that underpins Apple's older but still widely-used framework.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day, with 2–3 days per week dedicated to hands-on coding projects
- View Controller lifecycle and state management (viewDidLoad, viewWillAppear, viewDidDisappear, etc.)
- Auto Layout constraints and programmatic layout without storyboards
- UITableView and UITableViewController for displaying dynamic lists and handling delegation
- Navigation patterns: UINavigationController, segues, and passing data between view controllers
- MVC (Model-View-Controller) architecture and how UIKit enforces this separation
- Delegation and data source patterns as the foundation of UIKit communication
- UIView hierarchy, subclassing, and custom view creation
- Target-action pattern for handling user interactions (buttons, gestures)
- Explain the view controller lifecycle and when each method is called; when would you use viewDidLoad vs. viewWillAppear?
- How does Auto Layout work, and what is the difference between frame-based layout and constraint-based layout?
- What is the delegate pattern, and how does UITableViewDelegate differ from UITableViewDataSource?
- Describe the MVC pattern in UIKit: what belongs in the Model, View, and Controller layers?
- How do you pass data between view controllers using segues, and what are the limitations of this approach?
- What is the target-action pattern, and how is it used to handle button taps and other user interactions?
- Build a simple single-view app with UILabel, UITextField, and UIButton; use Auto Layout to make it responsive on different screen sizes
- Create a UITableViewController that displays a list of 20+ items (e.g., books, contacts) with custom UITableViewCell subclasses
- Implement a two-screen navigation flow using UINavigationController; pass data from the first screen to the second via a custom initializer or property
- Build a master-detail app where tapping a table row opens a detail view controller; update the detail view based on the selected item
- Create a custom UIView subclass (e.g., a card view or progress indicator) and add it to a view controller using Auto Layout
- Refactor a view controller to separate Model logic into a separate class; practice MVC by keeping business logic out of the view controller
Next up: Mastering UIKit fundamentals—view controllers, Auto Layout, and the delegation pattern—prepares you to tackle more advanced UIKit topics (custom animations, gesture recognizers, networking) and positions you to understand how SwiftUI differs from and improves upon UIKit's imperative approach.
The most respected beginner-to-intermediate UIKit book; it introduces Xcode, Interface Builder, and core iOS patterns through progressively complex projects that mirror real app development.
Modern UI with SwiftUI
IntermediateRebuild your UI intuition around SwiftUI's declarative, state-driven model — mastering views, bindings, the environment, navigation stacks, animations, and Combine integration.
▸ Study plan for this stage
Pace: 8–10 weeks, ~25–35 pages/day. "Thinking in SwiftUI" (weeks 1–6, ~200 pages); "SwiftUI Animations by Tutorials" (weeks 7–10, ~150 pages). Allocate 2–3 days per chapter for deep practice.
- SwiftUI's declarative paradigm: how to think in terms of state → view, not imperative UI updates
- View composition and the View protocol: building reusable, hierarchical UI components
- State management (@State, @Binding, @ObservedObject, @EnvironmentObject): when and how to use each
- The Environment and property wrappers: passing data down the view tree efficiently
- Navigation stacks (NavigationStack, NavigationLink): modern SwiftUI navigation patterns
- Animations and transitions: timing, curves, and combining animations with state changes
- Combine framework integration: reactive data flows and publishers in SwiftUI
- Performance optimization: understanding view identity, @ViewBuilder, and avoiding unnecessary redraws
- Explain the difference between @State, @Binding, and @ObservedObject. When would you use each in a real app?
- How does SwiftUI's declarative model differ from UIKit's imperative approach, and why does this change how you structure your code?
- What is the Environment, and how do you use it to pass data down a view hierarchy without prop drilling?
- Describe the relationship between state changes and view redraws. How does SwiftUI determine which views need to update?
- How do you combine animations with state changes to create smooth, coordinated transitions?
- What is a Publisher in Combine, and how do you integrate it with SwiftUI views using @StateObject or @ObservedObject?
- Build a todo list app with @State and @Binding: create a list view, add/delete items, and toggle completion status with proper state management.
- Refactor a multi-screen app using NavigationStack: implement a master-detail flow with proper navigation state handling.
- Create a custom environment value (e.g., theme, user preferences) and pass it down through a view hierarchy using @Environment.
- Build a form with validation: use @State for form fields and @Binding to pass values to child views, updating validation state in real time.
- Implement a complex animation sequence: animate multiple properties (opacity, scale, offset) in response to a single state change using withAnimation.
- Connect a Combine Publisher to a SwiftUI view: fetch data from a network call or timer, update @StateObject, and display results with proper error handling.
Next up: This stage grounds you in SwiftUI's declarative, state-driven mental model and modern patterns (navigation stacks, Combine integration), preparing you to tackle architecture and testing in the next stage—you'll now be ready to apply these fundamentals to larger, production-grade apps with proper separation of concerns.
Written by core Swift community figures, this short book retrains your mental model from imperative UIKit thinking to declarative SwiftUI thinking — the most important conceptual shift at this stage.
Provides the hands-on, chapter-by-chapter project work that Thinking in SwiftUI deliberately omits, covering navigation, lists, custom controls, and animations in a structured progression.
Architecture, Networking & Data
IntermediateDesign scalable, testable app architectures (MVVM, TCA concepts), handle async networking with async/await, persist data with Core Data or SwiftData, and write meaningful unit tests.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day with 2–3 days per week for hands-on coding projects
- MVVM architecture: separating UI logic from business logic through ViewModels and reactive bindings
- The Coordinator pattern for managing navigation flows and decoupling view controllers
- Async/await syntax for handling asynchronous networking operations cleanly and avoiding callback hell
- URLSession and REST API integration with proper error handling and request/response modeling
- Core Data fundamentals: NSManagedObject, NSFetchRequest, NSPredicate, and the persistence stack
- SwiftData as a modern alternative to Core Data with simplified syntax and automatic persistence
- Unit testing architectures: mocking dependencies, testing ViewModels, and verifying networking behavior
- Data synchronization strategies between network and local persistence layers
- How does MVVM separate concerns compared to MVC, and what role does the ViewModel play in handling business logic?
- What is the Coordinator pattern and how does it improve navigation management in complex apps?
- Explain the difference between async/await and completion handlers—what problems does async/await solve?
- How do you design a networking layer that is testable, and what dependencies should be mocked in unit tests?
- What are the key components of Core Data's persistence stack, and how do they interact?
- When would you choose SwiftData over Core Data, and what are the main API differences?
- How do you write unit tests for a ViewModel that depends on a networking service and a data repository?
- Refactor a simple MVC app into MVVM: extract business logic into a ViewModel, bind UI updates, and verify the separation of concerns
- Implement a Coordinator-based navigation system for a multi-screen feature (e.g., user onboarding flow) and test coordinator transitions
- Build a networking layer using async/await that fetches data from a public REST API (e.g., JSONPlaceholder), handles errors gracefully, and decodes JSON into Swift models
- Create a ViewModel that depends on a NetworkService and a DataRepository; write unit tests that mock both dependencies and verify correct behavior
- Design and implement a Core Data persistence layer: create entities, perform CRUD operations, write and execute NSFetchRequests with predicates, and handle migrations
- Migrate a Core Data app to SwiftData: convert entities to SwiftData models, update queries, and verify data persistence works identically
- Build a complete feature that fetches data from a network API, persists it to Core Data (or SwiftData), and displays it in a ViewModel-driven UI with proper error handling and loading states
Next up: This stage establishes the architectural and data-handling foundations needed for building production-ready apps; the next stage will build on these patterns to cover advanced topics like reactive programming, performance optimization, and testing strategies at scale.
Compares MVVM, Redux, and other real-world architectures with working code, giving you the vocabulary and trade-off awareness needed to structure apps that grow without becoming unmaintainable.
Core Data remains the backbone of local persistence in millions of apps; this tutorial-driven book covers the full stack — model design, migrations, and syncing with CloudKit — after architecture patterns are in place.
Discussion
Keep reading
Paths that share books, cover the same subject, or open a related topic.
