SwiftUI Fundamentals for Calm Apps

Why SwiftUI for Independent Developers

SwiftUI reduces the complexity barrier for iOS development. Instead of managing view controllers, delegates, and lifecycle methods, you describe what you want and let the framework handle the how. This means less boilerplate, fewer bugs, and more time focusing on user experience.

Core Principles

1. State Is Your Single Source of Truth

Use @State for local view state, @StateObject for data models, and @EnvironmentObject for app-wide data. When state changes, views automatically update. This eliminates entire categories of bugs related to keeping UI in sync with data.

2. Composition Over Inheritance

Build complex views by combining simple ones. A settings screen is just a List containing Sections containing rows. Each component is self-contained and reusable. This makes your codebase easier to understand and maintain.

3. Embrace Constraints

SwiftUI's design system encourages consistency. Use standard components like NavigationView, List, and Form. They work well out of the box and users already know how to interact with them. Customization should enhance, not replace, these foundations.

Practical Example: A Simple Task List

Here's a complete, functional task list in SwiftUI:

struct Task: Identifiable {
    let id = UUID()
    var title: String
    var isComplete: Bool
}

struct TaskListView: View {
    @State private var tasks = [Task]()
    @State private var newTaskTitle = ""
    
    var body: some View {
        NavigationView {
            List {
                ForEach($tasks) { $task in
                    HStack {
                        Image(systemName: task.isComplete ? "checkmark.circle.fill" : "circle")
                            .foregroundColor(task.isComplete ? .green : .gray)
                            .onTapGesture {
                                task.isComplete.toggle()
                            }
                        TextField("Task", text: $task.title)
                    }
                }
            }
            .navigationTitle("Tasks")
            .toolbar {
                Button("Add") {
                    tasks.append(Task(title: "New Task", isComplete: false))
                }
            }
        }
    }
}

That's it. No view controllers, no delegates, no table view data sources. Just data and a description of how to display it.

Common Mistakes to Avoid

Over-Using ObservableObject

Not everything needs to be an ObservableObject. Simple state can live in @State variables. Only create ObservableObjects when you need to share state across multiple views or when the logic is complex enough to deserve its own model.

Fighting the Framework

If you find yourself writing complex geometry calculations or manual layout code, step back. SwiftUI probably has a built-in solution. HStack, VStack, ZStack, and modifiers handle most layout needs.

Premature Abstraction

Start simple. Build your views inline first. Only extract components when you're actually reusing them or when a view is becoming hard to read. Abstraction has a cost—make sure the benefit is worth it.

Resources for Learning

Apple's official SwiftUI tutorials are excellent. Work through them in order. Build small, complete apps rather than reading endlessly. You'll learn more from one finished app than from ten half-built tutorials.

The SwiftUI documentation is your best reference. When you need to know what modifiers are available on a View, Command-click it in Xcode. Real understanding comes from building, not reading.