Zero to Hero
Short, focused posts (5-12 min) that teach Swift and iOS fundamentals from scratch. Numbered sequentially to form a complete learning path — start at the top and work your way down. Each post also works as a standalone reference.
1. Installing Xcode: Your iOS Development Toolkit
The absolute first step for any new iOS developer. Learn how to download Xcode, understand system requirements, and take a quick tour of the IDE interface.
2. Swift Playgrounds: Learn Swift Without a Full Project
Playgrounds are the fastest way to experiment with Swift code without creating a full Xcode project. Learn how to create, use, and leverage playgrounds for rapid experimentation.
3. Variables and Constants in Swift: `var` vs `let` Explained
Learn the difference between mutable and immutable values in Swift. Understand when to use `var` vs `let`, why the compiler prefers constants, and how to follow Swift naming conventions.
4. Swift Data Types: Strings, Integers, Doubles, and Booleans
A complete guide to Swift's fundamental data types. Learn how `String`, `Int`, `Double`, `Float`, and `Bool` work, when to use each, and how type safety prevents bugs at compile time.
5. Type Inference in Swift: How the Compiler Reads Your Mind
Swift can figure out the type of a variable without you telling it. Understand how type inference works, when to add type annotations manually, and the performance implications.
6. Swift Operators: Arithmetic, Comparison, and Logical Operators Explained
Master Swift's operators from basic arithmetic to advanced range operators. Covers comparison, ternary conditional, nil-coalescing, and operator precedence.
7. Working with Strings in Swift: Interpolation, Multiline, and Unicode
Deep dive into Swift's powerful String type. Learn string interpolation, multiline strings, character iteration, substring extraction, and why Swift strings aren't indexed by integers.
8. Swift Collections: Arrays, Dictionaries, and Sets Explained
Learn to store and organize groups of values using Swift's three primary collection types. Covers creation, access, mutation, iteration, and when to choose each type.
9. Control Flow in Swift: `if`, `switch`, `guard`, and Pattern Matching
Master Swift's control flow statements. Learn how `if/else`, `switch` with pattern matching, and `guard` for early exits make your code safer and more readable.
10. Loops in Swift: `for-in`, `while`, and `repeat-while` Explained
Everything about looping in Swift. Covers `for-in` with ranges and collections, `while` and `repeat-while`, `stride`, `enumerated()`, `zip`, and labeled statements.
11. Optionals in Swift: The Complete Guide to Handling `nil` Safely
Optionals are Swift's most distinctive feature. Learn what they are, why they exist, and how to unwrap them safely using `if let`, `guard let`, optional chaining, nil-coalescing, and force unwrapping.
12. Functions in Swift: Parameters, Return Types, and Overloading
A comprehensive guide to defining and calling functions. Covers argument labels, default parameters, variadic parameters, `inout`, multiple return values with tuples, and function overloading.
13. Closures in Swift: From Syntax to Real-World Usage
Demystify closures step by step. Learn closure syntax, trailing closure shorthand, capturing values, `@escaping` vs non-escaping, and how closures power APIs like `map`, `filter`, and `sorted`.
14. Enums in Swift: Associated Values, Raw Values, and Pattern Matching
Swift enums are far more powerful than in other languages. Learn raw values, associated values, computed properties, methods, `CaseIterable`, and combining enums with `switch` pattern matching.
15. Structs vs Classes in Swift: Understanding Value and Reference Types
The struct vs class decision is fundamental. Learn how each works, why Swift defaults to structs, how reference semantics affect shared state, and how to decide which to use.
16. Properties in Swift: Stored, Computed, Lazy, and Property Observers
Explore all the ways Swift lets you attach data to types. Covers stored properties, computed properties with getters/setters, `lazy` initialization, and property observers (`willSet`/`didSet`).
17. Methods and Subscripts in Swift: Instance, Type, and Mutating
Learn how to add behavior to your types. Covers instance methods, type methods (`static`/`class`), `mutating` methods for structs, and custom subscripts for bracket-access syntax.
18. `init` in Swift: Initializers, Convenience Inits, and Deinit
Understand how Swift objects come to life. Covers designated and convenience initializers, memberwise initializers, failable initializers (`init?`), required initializers, and `deinit` for cleanup.
19. Protocols in Swift: Defining Contracts and Enabling Polymorphism
Protocols are the backbone of Swift's design philosophy. Learn how to define, adopt, and conform to protocols, use protocol extensions for default implementations, and understand protocol-oriented programming.
20. Extensions in Swift: Adding Functionality Without Inheritance
Extensions let you add new methods, computed properties, initializers, and protocol conformances to any existing type — even types you didn't write. Learn how and when to use them.
21. Error Handling in Swift: `do`, `try`, `catch`, and `throws`
Learn Swift's structured error handling model. Covers defining custom errors with enums, throwing and catching errors, `try?` and `try!`, `rethrows`, and the `Result` type as an alternative.
22. Access Control in Swift: `public`, `private`, `internal`, and More
Control what's visible and what's hidden. Understand Swift's five access levels (`open`, `public`, `internal`, `fileprivate`, `private`), when to use each, and how access control improves API design.
23. Generics in Swift: Write Flexible, Reusable Code
Generics let you write functions and types that work with any type while maintaining compile-time safety. Learn generic functions, generic types, type constraints, and how the standard library uses generics.
24. Property Wrappers in Swift: How `@State`, `@Binding`, and Custom Wrappers Work
Property wrappers power SwiftUI and many Swift patterns. Understand how `@propertyWrapper` works under the hood, explore built-in wrappers like `@State` and `@AppStorage`, and learn to write your own.
25. The `Result` Type in Swift: Handling Success and Failure Elegantly
`Result<Success, Failure>` gives you a clean way to represent operations that can succeed or fail. Learn how it works with generics, how to transform results with `map`/`flatMap`, and when to use it vs `throws`.
26. `map`, `filter`, `reduce`, and `compactMap` in Swift Explained
Transform collections like a pro. Learn how `map`, `flatMap`, `compactMap`, `filter`, `reduce`, `sorted`, and `forEach` work, with practical examples showing when each is the right choice.
27. Value Types vs Reference Types in Swift: A Visual Guide
Why does copying a struct make an independent copy while copying a class shares the same instance? Understand copy-on-write, identity vs equality, and how this affects your architecture.
28. Getting Started with Xcode: Your First iOS Project
A tour of Xcode for complete beginners. Learn how to create a project, navigate the editor, use the canvas preview, run on the simulator, read build errors, and use basic debugging tools.
29. SwiftUI Basics: Building Your First View with `Text`, `Image`, and `VStack`
Build your first SwiftUI screen. Learn how views are declared, how to stack elements with `VStack`/`HStack`/`ZStack`, add text and images, apply modifiers, and preview your work live.
30. The SwiftUI Layout System: Stacks, Frames, Padding, and Spacers
Understand how SwiftUI positions views on screen. Learn the three-step layout process (parent proposes, child decides, parent places), and master `frame`, `padding`, `Spacer`, alignment, and `GeometryReader`.
31. State Management in SwiftUI: `@State`, `@Binding`, `@Observable`, and `@Environment`
The heart of SwiftUI is data-driven rendering. Learn how `@State` triggers view updates, `@Binding` shares state, `@Observable` replaced `ObservableObject`, and `@Environment` provides global values.
32. Lists and Navigation in SwiftUI: `List`, `NavigationStack`, and Detail Views
Build the most common iOS pattern — a scrollable list that navigates to a detail screen. Learn `List`, `ForEach`, `NavigationStack`, `NavigationLink`, and programmatic navigation.
33. Forms and User Input in SwiftUI: `TextField`, `Toggle`, `Picker`, and `Slider`
Collect user input with SwiftUI's built-in form controls. Learn `TextField`, `SecureField`, `Toggle`, `Picker`, `DatePicker`, `Slider`, `Stepper`, and how to validate and react to changes.
34. Presenting Views in SwiftUI: Sheets, Alerts, Confirmation Dialogs, and Popovers
Learn the different ways to present content on top of your current view. Covers `.sheet`, `.fullScreenCover`, `.alert`, `.confirmationDialog`, `.popover`, and the state-driven presentation model.
35. `TabView` and Toolbars in SwiftUI: Building App-Wide Navigation
Structure your app with tabs and toolbars. Learn `TabView`, custom tab bar styling, `.toolbar` with `ToolbarItem`, `.toolbarRole`, and combining tab and stack navigation.
36. Images in SwiftUI: SF Symbols, AsyncImage, and Custom Assets
Display images beautifully. Learn `Image` with asset catalogs, SF Symbols usage and customization, `AsyncImage` for remote images, `resizable()`, `aspectRatio`, `clipShape`, and overlays.
37. Networking in Swift: Fetching JSON with `URLSession` and `Codable`
Connect your app to the internet. Learn to make GET requests with `URLSession`, decode JSON using `Codable` and `JSONDecoder`, handle errors gracefully, and display remote data in SwiftUI.
38. Getting Started with `async`/`await` in Swift
Write asynchronous code that reads like synchronous code. Learn how `async`/`await` replaces completion handlers, how to call async functions, mark your own as `async`, and use `Task` to bridge sync and async.
39. Saving Data Locally: `UserDefaults` and `@AppStorage` in SwiftUI
Start persisting simple data in your app. Learn `UserDefaults` for storing preferences, `@AppStorage` for SwiftUI integration, supported data types, limitations, and when to reach for a real database.
40. Getting Started with SwiftData: Your First Persistent Model
SwiftData is Apple's modern persistence framework built on Swift macros. Learn to define `@Model` classes, set up a `ModelContainer`, perform CRUD operations with `@Query`, and bind persistent data to SwiftUI.
41. Understanding ARC: How Swift Manages Memory Automatically
Automatic Reference Counting handles memory for you — most of the time. Learn how ARC works, what retain cycles are, how `weak` and `unowned` references prevent leaks, and how to detect leaks in Xcode.
42. Using Swift Packages: Adding Dependencies to Your Xcode Project
Leverage the Swift ecosystem by adding third-party packages. Covers adding packages via Xcode, specifying version rules, understanding `Package.swift`, and popular packages worth knowing.