Blog
Essays, notes, and small SwiftUI experiments — written to be calm, practical, and useful.
SwiftUI Shapes Are Descriptions, Not Views
A mental model for understanding SwiftUI shapes as geometry descriptions instead of UI elements.
Using @FocusState for Better Form UX
A practical SwiftUI tutorial for managing field focus, keyboard navigation, and validation flow with @FocusState.
SF Symbols: Icons as Design Data
A perspective on SF Symbols as scalable design primitives, not image assets.
Enums in Swift: Models, Not Switches
Why Swift enums are powerful modeling tools, not just control flow helpers.
Property Wrappers in Swift: Boundaries, Not Magic
A mental model for understanding Swift property wrappers as explicit boundaries of responsibility.
Animating View Transitions with .transition
A practical SwiftUI tutorial for building smooth insertion and removal animations with transition, state ownership, and predictable layout behavior.
ViewThatFits: Adaptive Layouts in SwiftUI
Build adaptive SwiftUI layouts with ViewThatFits by declaring fallback variants instead of writing manual size logic.
SwiftUI ToolbarSpacer
A tiny SwiftUI trick to create separation.
Understanding Swift async/await: Flow, Not Syntax
A mental model for Swift’s async/await that focuses on execution flow instead of keywords.
Why your SwiftUI body must stay cheap
A short explanation of why expensive work does not belong in SwiftUI view bodies.
Building a Settings Row with Toggle and Detail
A step-by-step SwiftUI tutorial for a reusable settings row that supports toggle state, optional detail text, and clear ownership boundaries.
@Binding is not shared state
A clarification of why @Binding does not represent ownership or shared state in SwiftUI.
How to Structure a SwiftUI View File (A Beginner’s Guide)
A beginner-friendly mental model for structuring SwiftUI view files, including bindings, state, body, and methods.
Why onAppear Is Not Lifecycle
A short SwiftUI note on why onAppear should not be treated like UIViewController lifecycle.
Passing Bindings Through Multiple View Layers
A step-by-step SwiftUI approach to forwarding bindings through nested views without losing ownership clarity.
Callback Closures vs Bindings in SwiftUI
How to decide whether a child view should receive a Binding or an action closure.
Data Flows Down, Actions Flow Up
A practical mental model for designing SwiftUI screens that stay predictable as they grow.
Xcode: How to Navigate Large Swift Files Quickly
A short Xcode guide with practical navigation tricks and shortcuts for Swift files.
Guard vs. If Let in Swift (and when to use each)
A practical mental model for choosing guard, if let, and optional handling patterns in Swift, with comparisons to common patterns in other languages.
Understanding Optionals in Swift (and common pitfalls)
A practical beginner-friendly guide to Swift optionals: what they are, when to use them, and how to avoid common mistakes like force unwrapping.
Extracting a reusable SwiftUI component cleanly
How to refactor a SwiftUI view into a reusable component without breaking data flow.
Why SwiftUI views are structs (and why that matters)
A brief explanation of why SwiftUI uses value types for views and how that shapes the framework.
Why SwiftUI Recomposes Views (and Why That’s Fine)
A clear mental model explaining why SwiftUI recomputes views and how to design with it instead of fighting it.
Building an expandable add button in SwiftUI
A simple floating action button that expands into multiple actions using pure SwiftUI.
Views are value types, not objects
Why SwiftUI views behave differently than UIKit views — and why that is a feature, not a limitation.
State vs Binding: A Mental Model
A simple mental model for deciding when to use @State and when to use @Binding in SwiftUI.
Preventing Screenshots in SwiftUI: What’s Possible (and What Isn’t)
An honest look at screenshot prevention in SwiftUI: platform limits, UIKit bridges, and realistic security expectations.
SwiftUI Is a Language for Data Flow (Not Layout)
SwiftUI is best understood not as a layout system, but as a language for expressing data flow and ownership. A calmer mental model for modern SwiftUI.