Swift and SwiftUI on Software Engineering Learning Paths

Swift Fundamentals

Mon, 01 Jan 0001 00:00:00 +0000

Swift Fundamentals#

Swift is a compiled, statically-typed language designed for safety and performance. It eliminates entire categories of bugs through its type system, particularly its handling of nil values through optionals.

Variables and Constants#

Swift distinguishes between mutable and immutable bindings at the declaration site:

let maximumAttempts = 3 // Constant — cannot be reassigned
var currentAttempt = 0 // Variable — can be reassigned

currentAttempt += 1 // OK
// maximumAttempts = 5 // Compile error: cannot assign to 'let' constant

Prefer let over var whenever possible. The compiler enforces immutability, making code easier to reason about and safer in concurrent contexts.

Functions and Closures

Mon, 01 Jan 0001 00:00:00 +0000

Functions and Closures#

Functions are first-class citizens in Swift — they can be assigned to variables, passed as arguments, and returned from other functions. Closures are self-contained blocks of functionality that capture their surrounding context.

Function Syntax#

A Swift function has a name, parameter list, and return type:

func greet(person: String) -> String {
 return "Hello, \(person)!"
}

let message = greet(person: "Alice") // "Hello, Alice!"

Functions with no return value implicitly return Void (a type alias for ()):

func logMessage(_ message: String) {
 print("[LOG] \(message)")
}

Single-Expression Functions#

When the body is a single expression, the return keyword is implicit:

Collections and Enumerations

Mon, 01 Jan 0001 00:00:00 +0000

Collections and Enumerations#

Swift provides three primary collection types — Array, Set, and Dictionary — alongside enumerations that are far more powerful than their counterparts in most languages.

Arrays#

Arrays are ordered collections of values of the same type:

// Type-inferred creation
var temperatures = [72.0, 68.5, 74.2, 69.8]

// Explicit type annotation
var names: [String] = []

// Array with repeated values
let zeros = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]

Array Operations#

var fruits = ["Apple", "Banana", "Cherry"]

// Access
let first = fruits[0] // "Apple"
let last = fruits.last // Optional("Cherry")

// Modification
fruits.append("Date") // Add to end
fruits.insert("Avocado", at: 1) // Insert at index
fruits.remove(at: 0) // Remove at index
fruits.removeLast() // Remove last element

// Querying
let count = fruits.count // Number of elements
let empty = fruits.isEmpty // false
let hasCherry = fruits.contains("Cherry") // true

// Transformation
let uppercased = fruits.map { $0.uppercased() }
let short = fruits.filter { $0.count < 6 }
let sorted = fruits.sorted() // New sorted array (non-mutating)
fruits.sort() // In-place sort (mutating)

Array Slicing#

let numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

let firstThree = numbers[0..<3] // [0, 1, 2] — ArraySlice
let lastThree = numbers.suffix(3) // [7, 8, 9]
let middle = numbers[3...6] // [3, 4, 5, 6]

// Convert slice back to Array
let sliceArray = Array(numbers[2..<5]) // [2, 3, 4]

Sets#

Sets are unordered collections of unique values. They provide O(1) lookup and support mathematical set operations:

Structs and Classes

Mon, 01 Jan 0001 00:00:00 +0000

Structs and Classes#

Swift provides two mechanisms for defining custom types: structs (value types) and classes (reference types). Understanding their differences is fundamental to writing correct Swift code.

Value Types vs Reference Types#

graph TD
 subgraph "Value Type (Struct)"
 A[var a = Point&lpar;x: 1, y: 2&rpar;] --> B[Memory: x=1, y=2]
 C["var b = a (copy)"] --> D[Memory: x=1, y=2]
 E["b.x = 5"] --> F[a unchanged: x=1, y=2]
 end

 subgraph "Reference Type (Class)"
 G[var c = Person&lpar;name: &quot;Alice&quot;&rpar;] --> H[Heap: name=&quot;Alice&quot;]
 I["var d = c (shared reference)"] --> H
 J["d.name = &quot;Bob&quot;"] --> K["c.name is also &quot;Bob&quot;"]
 end

Characteristic	Struct (Value Type)	Class (Reference Type)
Storage	Stack (usually)	Heap
Assignment	Copies the value	Copies the reference
Identity	No identity — equality by value	Has identity (`===` operator)
Mutability	`mutating` keyword required	Mutable through any reference
Inheritance	❌	✅
Deinitializers	❌	✅ (`deinit`)
Reference counting	❌	✅ (ARC)

When to Use Which#

Use structs (the default choice) when:

Protocols and Generics

Mon, 01 Jan 0001 00:00:00 +0000

Protocols and Generics#

Swift is a protocol-oriented language. Protocols define contracts that types must fulfill, while generics enable code reuse across types. Together, they form the backbone of Swift’s abstraction system.

Protocols#

A protocol defines a blueprint of methods, properties, and requirements:

protocol Drawable {
 var boundingBox: CGRect { get }
 func draw(on canvas: Canvas)
}

protocol Resizable {
 mutating func resize(by factor: Double)
}

Property Requirements#

Protocols specify whether properties must be gettable or gettable-and-settable:

protocol Named {
 var name: String { get } // Read-only requirement
 var nickname: String { get set } // Read-write requirement
}

// Conforming with stored property (satisfies both get and get/set)
struct User: Named {
 var name: String // var satisfies { get }
 var nickname: String // var satisfies { get set }
}

// Conforming with computed property
struct AnonymousUser: Named {
 var name: String { "Anonymous" } // Computed, read-only
 var nickname: String { // Computed, read-write
 get { "Anon" }
 set { /* ignore */ }
 }
}

Method Requirements#

protocol DataSource {
 func numberOfItems() -> Int
 func item(at index: Int) -> String
 mutating func addItem(_ item: String) // mutating for value types
}

Protocol Conformance#

struct Circle: Drawable, Resizable {
 var center: CGPoint
 var radius: Double

 var boundingBox: CGRect {
 CGRect(x: center.x - radius, y: center.y - radius,
 width: radius * 2, height: radius * 2)
 }

 func draw(on canvas: Canvas) {
 canvas.drawCircle(center: center, radius: radius)
 }

 mutating func resize(by factor: Double) {
 radius *= factor
 }
}

Protocol Inheritance#

Protocols can inherit from other protocols:

Error Handling and Concurrency

Mon, 01 Jan 0001 00:00:00 +0000

Error Handling and Concurrency#

Swift provides structured error handling with throws/try/catch and modern concurrency with async/await, actors, and structured task hierarchies.

Error Handling#

Defining Errors#

Errors conform to the Error protocol (usually implemented with enums):

enum NetworkError: Error {
 case invalidURL
 case noConnection
 case timeout(seconds: Int)
 case httpError(statusCode: Int, message: String)
}

enum ValidationError: Error, LocalizedError {
 case tooShort(minimum: Int)
 case invalidFormat(expected: String)

 var errorDescription: String? {
 switch self {
 case .tooShort(let min):
 return "Input must be at least \(min) characters"
 case .invalidFormat(let expected):
 return "Expected format: \(expected)"
 }
 }
}

Throwing and Catching#

func fetchUser(id: Int) throws -> User {
 guard id > 0 else {
 throw ValidationError.invalidFormat(expected: "positive integer")
 }

 let response = try makeRequest(url: "/users/\(id)")

 guard response.statusCode == 200 else {
 throw NetworkError.httpError(
 statusCode: response.statusCode,
 message: response.body
 )
 }

 return try decode(response.body)
}

// Calling throwing functions
do {
 let user = try fetchUser(id: 42)
 print("Got user: \(user.name)")
} catch NetworkError.httpError(404, _) {
 print("User not found")
} catch NetworkError.timeout(let seconds) {
 print("Request timed out after \(seconds)s")
} catch {
 print("Unexpected error: \(error)") // 'error' is implicit
}

Try Variants#

Syntax	Behavior	Use When
`try`	Propagates error to caller	Inside a `do-catch` or throwing function
`try?`	Returns `nil` on error	You don’t care about the specific error
`try!`	Crashes on error	You’re certain it won’t fail (rare)

// try? — converts to optional
let user = try? fetchUser(id: 42) // User? — nil if any error

// Combine with nil coalescing
let name = (try? fetchUser(id: 1))?.name ?? "Unknown"

// try! — force (crashes on error)
let config = try! loadConfig() // Only for truly impossible failures

Rethrowing Functions#

Functions that only throw if their closure argument throws:

SwiftUI Fundamentals

Mon, 01 Jan 0001 00:00:00 +0000

SwiftUI Fundamentals#

SwiftUI is Apple’s declarative UI framework. Instead of imperatively constructing and mutating view hierarchies, you describe what the UI should look like for a given state, and the framework handles the rendering and updates.

The View Protocol#

Every SwiftUI view conforms to the View protocol:

protocol View {
 associatedtype Body: View
 @ViewBuilder var body: Self.Body { get }
}

A view is a lightweight struct that describes a piece of UI:

struct GreetingView: View {
 var body: some View {
 Text("Hello, World!")
 }
}

graph TD
 A[State changes] --> B[SwiftUI re-evaluates body]
 B --> C[Diff against previous render]
 C --> D[Apply minimal updates to screen]
 D --> E[User sees updated UI]
 E -->|User interaction| A

Key Insight: Views Are Values#

SwiftUI views are value types (structs). They are cheap to create, destroyed after each render, and recreated when state changes. The framework uses the view hierarchy as a blueprint to manage the actual rendered UI efficiently.

SwiftUI State Management

Mon, 01 Jan 0001 00:00:00 +0000

SwiftUI State Management#

State management is the core of SwiftUI. The framework provides property wrappers that connect data to views, ensuring the UI automatically reflects the current state.

The Principle: Single Source of Truth#

Every piece of data in a SwiftUI app should have one owner. Other views receive a reference or binding to that data rather than creating their own copy.

graph TD
 A[Source of Truth<br/>@State / @StateObject / @Observable] --> B[View A reads directly]
 A -->|$binding| C[View B modifies via binding]
 A -->|Passed down| D[View C reads value]
 C -->|Change| A
 A -->|Triggers re-render| B
 A -->|Triggers re-render| D

@State#

@State manages simple value types owned by the view. SwiftUI persists the value across re-renders:

SwiftUI Navigation

Mon, 01 Jan 0001 00:00:00 +0000

SwiftUI provides several navigation paradigms: stack-based hierarchical navigation, modal presentations (sheets), alerts, and tab-based navigation. iOS 16+ introduced NavigationStack with programmatic, type-safe navigation paths.

NavigationStack#

NavigationStack manages a push/pop navigation hierarchy:

struct ContentView: View {
 var body: some View {
 NavigationStack {
 List {
 NavigationLink("Profile", value: Route.profile)
 NavigationLink("Settings", value: Route.settings)
 NavigationLink("User #42", value: Route.user(id: 42))
 }
 .navigationTitle("Home")
 .navigationDestination(for: Route.self) { route in
 switch route {
 case .profile:
 ProfileView()
 case .settings:
 SettingsView()
 case .user(let id):
 UserDetailView(id: id)
 }
 }
 }
 }
}

enum Route: Hashable {
 case profile
 case settings
 case user(id: Int)
}

NavigationLink Styles#

// Value-based (preferred — decouples link from destination)
NavigationLink("Show Detail", value: item)

// View-based (inline destination — simpler but less flexible)
NavigationLink("Show Detail") {
 DetailView(item: item)
}

// Custom label
NavigationLink(value: Route.profile) {
 HStack {
 Image(systemName: "person.circle")
 Text("View Profile")
 }
}

For full control over the navigation stack, bind it to a NavigationPath:

SwiftUI Lists and Data

Mon, 01 Jan 0001 00:00:00 +0000

SwiftUI Lists and Data#

Lists are the most common way to display collections of data in iOS apps. SwiftUI’s List and ForEach provide efficient, scrollable displays with built-in support for selection, swipe actions, and dynamic content.

List Basics#

struct FruitListView: View {
 let fruits = ["Apple", "Banana", "Cherry", "Date", "Elderberry"]

 var body: some View {
 List(fruits, id: \.self) { fruit in
 Text(fruit)
 }
 }
}

The Identifiable Protocol#

For custom types, conform to Identifiable so SwiftUI can track items efficiently:

struct Task: Identifiable {
 let id = UUID()
 var title: String
 var isCompleted: Bool
 var priority: Priority

 enum Priority: String, CaseIterable {
 case low, medium, high
 }
}

struct TaskListView: View {
 @State private var tasks: [Task] = [
 Task(title: "Buy groceries", isCompleted: false, priority: .medium),
 Task(title: "Walk the dog", isCompleted: true, priority: .high),
 Task(title: "Read book", isCompleted: false, priority: .low),
 ]

 var body: some View {
 List(tasks) { task in // No id: parameter needed — Task is Identifiable
 TaskRow(task: task)
 }
 }
}

ForEach#

ForEach generates views from a collection. It’s used inside List, VStack, and other containers:

Animations and Gestures

Mon, 01 Jan 0001 00:00:00 +0000

Animations and Gestures#

SwiftUI provides a powerful, declarative animation system. You describe the target state, and the framework interpolates the transition. Combined with gesture recognizers, you can build fluid, interactive experiences.

Implicit Animations#

Attach .animation() to a view — any change to the specified value is animated:

struct PulsingCircle: View {
 @State private var isExpanded = false

 var body: some View {
 Circle()
 .fill(.blue)
 .frame(width: isExpanded ? 200 : 100,
 height: isExpanded ? 200 : 100)
 .animation(.easeInOut(duration: 0.5), value: isExpanded)
 .onTapGesture {
 isExpanded.toggle()
 }
 }
}

Implicit animations watch a specific value and animate any view changes caused by that value changing.

App Architecture

Mon, 01 Jan 0001 00:00:00 +0000

App Architecture#

Building production-quality SwiftUI apps requires architecture that separates concerns, enables testing, and scales with complexity. This section covers MVVM, dependency injection, SwiftData for persistence, networking with URLSession, and the app lifecycle.

App Lifecycle#

The @main Entry Point#

Every SwiftUI app starts with a struct conforming to App:

@main
struct MyApp: App {
 @State private var appState = AppState()

 var body: some Scene {
 WindowGroup {
 ContentView()
 .environment(appState)
 }
 }

 init() {
 // App-wide setup (configure logging, analytics, etc.)
 setupAppearance()
 }
}

Scenes#

Scenes represent a window or set of windows:

Swift and SwiftUI on Software Engineering Learning Paths

Swift Fundamentals

Swift Fundamentals#

Variables and Constants#

Functions and Closures

Functions and Closures#

Function Syntax#

Single-Expression Functions#

Collections and Enumerations

Collections and Enumerations#

Arrays#

Array Operations#

Array Slicing#

Sets#

Structs and Classes

Structs and Classes#

Value Types vs Reference Types#

When to Use Which#

Protocols and Generics

Protocols and Generics#

Protocols#

Property Requirements#

Method Requirements#

Protocol Conformance#

Protocol Inheritance#

Error Handling and Concurrency

Error Handling and Concurrency#

Error Handling#

Defining Errors#

Throwing and Catching#

Try Variants#

Rethrowing Functions#

SwiftUI Fundamentals

SwiftUI Fundamentals#

The View Protocol#

Key Insight: Views Are Values#

SwiftUI State Management

SwiftUI State Management#

The Principle: Single Source of Truth#

@State#

SwiftUI Navigation

SwiftUI Navigation#

NavigationStack#

NavigationLink Styles#

Programmatic Navigation with Path#

SwiftUI Lists and Data

SwiftUI Lists and Data#

List Basics#

The Identifiable Protocol#

ForEach#

Animations and Gestures

Animations and Gestures#

Implicit Animations#

App Architecture

App Architecture#

App Lifecycle#

The @main Entry Point#

Scenes#