Swift Quest

Tracks

1. 01🗺️The Map Before the Code

   0/6 lessons

   Toolchains, bundles, signatures, and the line between Apple's law and a house rule

   Before a single view, get the ground under your feet right. Why the family moved from web shells to Swift, which of the four "Swift versions" you actually mean, what an app bundle really is, why macOS identifies your app by its signature, how this quest labels Apple's law against our house rules — including the paid membership it assumes — and the specific ways coding agents go wrong on Apple platforms.

   Lesson list (6)

   • 01
     Why Native, and Why Swift~13 min · platform-map, native, swift, decision
   • 02
     The Toolchain You Actually Have~14 min · platform-map, xcode, command-line-tools, versions
   • 03
     An App Is a Folder~14 min · platform-map, bundle, info-plist, identity
   • 04
     To macOS, Your App Is Its Signature~15 min · platform-map, code-signing, designated-requirement, tcc
   • 05
     Apple's Law, Our House Rules~15 min · platform-map, house-rules, developer-program, testflight
   • 06
     Where Coding Agents Go Wrong on Apple Platforms~15 min · platform-map, coding-agents, sdk, verification

   ✓Quiz · 4 questions→

2. 02🐦The Swift Apple Work Needs

   0/6 lessons

   Values and types, honest optionals, delegates that survive, errors that name themselves, Codable as migration

   Not a Swift primer — the specific Swift that decides whether an Apple app keeps its users' data. Structs for facts and classes for identity, enums that make wrong calls impossible, optionals that do not quietly swallow a missing entitlement, delegates that are usually weak and always single, errors that carry their own remedy, Codable documents that tolerate the files older builds wrote, and strings and timestamps that look equal while their bytes disagree.

   Lesson list (6)

   • 01
     Values, References, and Types That Refuse Wrong Answers~15 min · swift-for-apple, structs, classes, enums, modeling
   • 02
     Optionals, and the Early Return That Loses Data~14 min · swift-for-apple, optionals, guard, silent-failure
   • 03
     Protocols, Delegates, and the Weak Reference That Vanishes~15 min · swift-for-apple, protocols, delegates, arc, objc-runtime
   • 04
     Errors That Say What Went Wrong~15 min · swift-for-apple, errors, typed-throws, objc-exceptions
   • 05
     Adding One Field Is a Migration~16 min · swift-for-apple, codable, persistence, migration
   • 06
     Strings, Dates, and Bytes That Look Equal~16 min · swift-for-apple, unicode, dates, iso8601, data

   ✓Quiz · 4 questions→

3. 03🧵Concurrency and Isolation

   0/7 lessons

   The boss track: language modes, actors, Sendable, and the closure that trapped off the main thread

   The track where Apple apps actually crash. Why the main thread is a room with one door, why Swift 5 and Swift 6 language modes make the same source mean different things, how actors, @MainActor and Sendable meet frameworks designed before them, the realtime-thread crash that no Simulator could reach, Swift 6.2's main-actor-first defaults, why every await is a door someone can close, and why blocking work must never sit on the cooperative pool.

   Lesson list (7)

   • 01
     The Main Thread Is a Room With One Door~15 min · concurrency, main-thread, mainactor, responsiveness
   • 02
     Swift 5 Mode, Swift 6 Mode, and the Same Source Meaning Two Things~15 min · concurrency, language-mode, swift-6, strict-concurrency
   • 03
     Actors, @MainActor, and Sendable at the Framework Boundary~17 min · concurrency, actors, sendable, isolated-conformance, nonisolated
   • 04
     The Closure That Trapped on a Realtime Thread~18 min · concurrency, isolation-inference, sendable, objc-boundary, boss
   • 05
     Swift 6.2's New Defaults: Main Actor First, Concurrency on Purpose~16 min · concurrency, swift-6-2, default-isolation, nonisolated-nonsending, concurrent
   • 06
     Every await Is a Door Someone Can Close~17 min · concurrency, reentrancy, cancellation, continuations, deadlines
   • 07
     Blocking Work Does Not Belong on the Cooperative Pool~16 min · concurrency, thread-pool, blocking-io, performance, testing

   ✓Quiz · 5 questions→

4. 04📦Packages and Projects

   0/6 lessons

   Package.swift, C shims, path dependencies, XcodeGen, three test styles, and one package for many apps

   How Apple code is organized and built outside the Xcode UI. Reading and writing Package.swift, wrapping a C API in a one-file target, the four ways a path dependency lies to you, why project.yml is the source of every iOS project and the pbxproj is output, which of Swift Testing, XCTest and a self-test executable does which job, and how one package serves a Mac app, an iPhone app and a watch app without a green host build hiding broken platform code.

   Lesson list (6)

   • 01
     Reading and Writing Package.swift~15 min · packages-projects, swiftpm, manifest, modules
   • 02
     When Swift Needs C~15 min · packages-projects, c-interop, system-libraries, swiftpm
   • 03
     A Path Dependency Compiles Someone Else's Working Tree~16 min · packages-projects, swiftpm, path-dependency, stale-builds, diagnosis
   • 04
     project.yml Is the Source; the Xcode Project Is Output~16 min · packages-projects, xcodegen, xcode-project, ios, targets
   • 05
     Swift Testing, XCTest, and the Self-Test Executable~16 min · packages-projects, swift-testing, xctest, selftest, test-design
   • 06
     One Swift Package, Many Apps and Platforms~16 min · packages-projects, shared-code, platform-fences, build-matrix, kit

   ✓Quiz · 4 questions→

5. 05🪟AppKit and SwiftUI on the Mac

   0/6 lessons

   Four app shapes, launch races, bridged views, observation, the responder chain, and where AppKit still wins

   How real Mac apps combine AppKit and SwiftUI. The four shapes the family's apps take and how to choose one, where an app begins and how launch and quit can race your code, who owns an AppKit object inside SwiftUI, why @Observable replaced ObservableObject after a microphone button that looked broken, how a key press finds its handler, and the text, split-view, drag and window-chrome details that keep the biggest apps in AppKit.

   Lesson list (6)

   • 01
     Four Ways to Hold a Mac App Together~15 min · appkit-swiftui, architecture, swiftui, appkit, menu-bar
   • 02
     Where a Mac App Begins, and How It Ends~16 min · appkit-swiftui, lifecycle, nsapplication, open-urls, termination
   • 03
     NSViewRepresentable and NSHostingView: Who Owns the Object~16 min · appkit-swiftui, nsviewrepresentable, nshostingview, lifetimes, wkwebview
   • 04
     @Observable Versus ObservableObject~15 min · appkit-swiftui, observation, swiftui, state
   • 05
     The Responder Chain and Keyboard Input~16 min · appkit-swiftui, responder-chain, keyboard, nsevent, menus
   • 06
     Text, Splits and Windows: Where AppKit Still Wins~17 min · appkit-swiftui, nstextview, nssplitview, window-chrome, drag-and-drop

   ✓Quiz · 4 questions→

6. 06🔏Bundles, Signing and Grants

   0/6 lessons

   From a build product to a signed app, the requirement that names it, a self-signed identity on purpose, TCC, Keychain ACLs, and the roads not taken

   What turns a compiled executable into an app macOS will remember. How a build script assembles and signs a bundle, what a designated requirement is and why an ad-hoc signature changes it on every build, why the family signs every Mac app with one self-signed identity and what that costs, how TCC attributes permissions to the responsible process, why a Keychain item keeps trusting the build that created it, and what the hardened runtime, notarization and the App Sandbox actually do before you decide to leave them off.

   Lesson list (6)

   • 01
     From swift build to a Real, Installed .app~17 min · bundle-signing, bundling, codesign, install, scripts
   • 02
     The Designated Requirement, Read and Tested~15 min · bundle-signing, designated-requirement, codesign, identity
   • 03
     A Self-Signed Signing Identity, On Purpose~16 min · bundle-signing, self-signed, code-signing-identity, tcc, keychain
   • 04
     TCC: What macOS Remembers About Your App~17 min · bundle-signing, tcc, accessibility, privacy, permissions
   • 05
     Keychain Items Belong to the App That Made Them~15 min · bundle-signing, keychain, secrets, acl, security-framework
   • 06
     The Roads Not Taken: Hardened Runtime, Notarization, Sandbox~16 min · bundle-signing, hardened-runtime, notarization, app-sandbox, library-validation

   ✓Quiz · 4 questions→

7. 07🏛️Living as a macOS Citizen

   0/6 lessons

   LaunchServices, launchd agents, the GUI session versus ssh, menu-bar utilities, global hotkeys, and URL schemes

   What a Mac app has to get right once it lives alongside the system instead of inside Xcode. How LaunchServices finds and launches apps and why /Applications is one slot every checkout shares, how a LaunchAgent keeps a utility alive without resurrecting it after a Quit, what an ssh session cannot do and how remote tooling reaches the GUI session anyway, why a healthy menu-bar app can have an icon nobody can see, how global hotkeys are registered and named, and why a URL scheme must never carry a command.

   Lesson list (6)

   • 01
     LaunchServices and the One Slot in /Applications~15 min · macos-citizen, launchservices, install, open, verification
   • 02
     launchd Agents: Keeping a Utility Alive Without Fighting It~17 min · macos-citizen, launchd, launchagent, keepalive, deployment
   • 03
     The GUI Session, the ssh Session, and the launchd Job~18 min · macos-citizen, ssh, aqua, launchd, codesign, fleet
   • 04
     Menu-Bar Utilities and the Icon Nobody Can See~15 min · macos-citizen, menu-bar, nsstatusitem, lsuielement, diagnostics
   • 05
     Global Hotkeys: Chords, Bare Modifiers, and Keys Without Names~17 min · macos-citizen, hotkeys, carbon, accessibility, keycodes
   • 06
     URL Schemes: A Door Any Page Can Knock On~16 min · macos-citizen, url-schemes, deep-links, launchservices, security

   ✓Quiz · 4 questions→

8. 08📱The Universal iPhone and iPad App

   0/6 lessons

   One target for both devices, a lifecycle where backgrounding is normal, UIKit for text, honest permission strings, Data Protection, and actions on a tap

   How the family builds one app for the iPhone and the iPad. Why a single universal target adapts by size class and why a selected row must never vanish from a collapsed split view, how a thin client treats backgrounding as the normal case and why an update can move the app's container, where UIKit's text system is still needed and how Korean composition constrains an editor, why a missing usage string terminates the app and a present one can still mislead, how Data Protection decides when the app can read its own files, and why every row's actions open on a tap.

   Lesson list (6)

   • 01
     One Target, Two Devices, Layout by Size Class~15 min · universal-ios, swiftui, navigationsplitview, size-classes, xcodegen
   • 02
     The iOS Lifecycle: Backgrounding Is Normal, and the Container Moves~16 min · universal-ios, lifecycle, scenephase, sandbox, file-identity
   • 03
     Where UIKit Is Still Needed: Text, Composition, and the Hardware Keyboard~17 min · universal-ios, uikit, uitextview, korean-input, swiftui
   • 04
     Permission Strings: The Sentence That Can Crash Your App or Lie~15 min · universal-ios, privacy, info-plist, speech, dictation
   • 05
     Data Protection: Choosing When Your Own App Can Read Its Files~15 min · universal-ios, data-protection, security, files, background
   • 06
     A Row's Actions Open on a Tap~13 min · universal-ios, swiftui, interaction, consistency, menus

   ✓Quiz · 4 questions→

9. 09🧩Reaching Outside the App

   0/6 lessons

   App Groups, the share extension, App Intents, widgets and Live Activities, push notifications, and the camera

   The doors a native app opens that a web page cannot. How an App Group gives every target that shares the entitlement one drop box, and why an unsigned build silently has none; how a share extension is offered, decides what an attachment is, loads it with a deadline and never succeeds silently; how App Intents reach Siri, Shortcuts and the Action Button and why execution must be proven on a device; what a widget should and should not show and how Live Activities start by push; the silent failures of APNs environments, keys and delegates; and the camera as a capture surface with photos downscaled before they leave the phone.

   Lesson list (6)

   • 01
     App Groups: One Drop Box for Every Door Into the App~15 min · beyond-the-app, app-groups, entitlements, extensions, capture
   • 02
     The Share Extension: Offered, Loaded, Written, and Never Silent~18 min · beyond-the-app, share-extension, nsitemprovider, activation-rule, uniform-type-identifiers
   • 03
     App Intents: Siri, Shortcuts and the Action Button Without Opening the App~17 min · beyond-the-app, app-intents, shortcuts, siri, testing
   • 04
     Widgets and Live Activities: A Number on the Home Screen, a Turn on the Lock Screen~17 min · beyond-the-app, widgetkit, activitykit, live-activities, push
   • 05
     Push Notifications: Silent Failures in Every Direction~17 min · beyond-the-app, push, apns, usernotifications, swift-concurrency
   • 06
     The Camera as a Capture Surface, and What a Photo Costs~14 min · beyond-the-app, camera, uiimagepickercontroller, images, privacy

   ✓Quiz · 4 questions→

10. 10⌚On the Wrist

    0/7 lessons

    A five-second surface, the embedded watch target, WatchConnectivity with the phone as engine, the wrist outbox, dictation, the complication as a button, and the Action Button

    How a family app becomes a thought captured in five seconds on a watch. Why the wrist has one door and every status line speaks only from facts it holds, how the watch app and its complication ride inside the iOS bundle with explicit Info.plists the upload gate checks, how WatchConnectivity pairs a durable transfer with a doorbell message through one retained delegate, why the watch keeps its own queue and lets go only on didFinish, how dictation opens with nil suggestions and switches language with a swipe up, why a complication is a button with no count, and how the Action Button reaches an app through a published shortcut and a one-shot launch request.

    Lesson list (7)

    • 01
      The Watch Is a Five-Second Surface~14 min · on-the-wrist, watchos, design, capture, status
    • 02
      The Watch Target: Embedded, Explicit, and Checked in the Archive~16 min · on-the-wrist, watchos, xcodegen, info-plist, simulator
    • 03
      WatchConnectivity: A Record, a Doorbell, and One Delegate~18 min · on-the-wrist, watchconnectivity, wcsession, delegates, property-lists
    • 04
      The Wrist Outbox: The Only Copy Until the Phone Says So~17 min · on-the-wrist, outbox, idempotency, watchconnectivity, data-safety
    • 05
      Dictation on the Wrist: nil, Not an Empty List, and a Swipe Up~16 min · on-the-wrist, dictation, watchkit, korean-input, verification
    • 06
      The Complication Is a Button, Not a Dashboard~14 min · on-the-wrist, complications, widgetkit, watch-face, deep-links
    • 07
      The Action Button: A Shortcut, a One-Shot Request, and a Retry~15 min · on-the-wrist, action-button, app-intents, shortcuts, cold-launch

    ✓Quiz · 4 questions→

11. 11🏠Talking to the Engine at Home

    0/6 lessons

    Thin clients, hardened URLSession, the lone ATS key, a Swift engine behind Serve twins, WebSockets that reconnect honestly, and an outbox that never loses a capture

    How a family app reaches the engine that owns its record. Why the engine stays on one Mac at home and the app is a thin client over the tailnet, how a URLSession call refuses redirects and enforces a byte budget while reading, what App Transport Security blocks and why its blanket key must stand alone, why a Swift engine behind a Tailscale Serve twin listens with bind(2), how a WebSocket client tells a dead peer from a quiet one and reconnects without replaying commands, and how an outbox keeps offline captures safe through retries, duplicates and app updates.

    Lesson list (6)

    • 01
      The Engine Stays Home: Apps as Thin Clients~16 min · engine-at-home, thin-client, tailnet, architecture, endpoints
    • 02
      URLSession With a Budget, a Refusal, and a Deadline~17 min · engine-at-home, urlsession, networking, performance, swift-concurrency
    • 03
      App Transport Security and the Key That Must Be Alone~16 min · engine-at-home, ats, info-plist, networking, diagnostics
    • 04
      A Swift Engine: Loopback, Serve Twins, and bind(2)~18 min · engine-at-home, server, bind, network-framework, tailscale-serve
    • 05
      WebSockets: Reconnect the Connection, Never the Command~17 min · engine-at-home, websockets, reconnect, heartbeat, urlsession
    • 06
      The Outbox: A Capture Is Never Lost~18 min · engine-at-home, outbox, offline, idempotency, sync

    ✓Quiz · 4 questions→

12. 12✈️Shipping Through TestFlight

    0/7 lessons

    Delivery as four facts, identifiers in order, unattended signing, build numbers, an export that cannot lie, gates on the artifact, and reading what is installed

    How a family iOS build gets from a commit to a device. Why TestFlight, not a cable install, is delivery and why a report names one of four facts, why the archive registers identifiers before App Store Connect chooses one, how a pipeline authenticates and signs with nobody at the keyboard, where build numbers live and what the rolling upload cap does, how to archive and upload so a failed export can never print success, which checks read the archive before Apple does, and how processed, assigned and installed are each verified.

    

    Lesson list (7)

    • 01
      Delivery Is TestFlight, and It Is Four Facts~15 min · testflight, delivery, app-store-connect, pipeline, reporting
    • 02
      Identifiers Come Into Existence in an Order~15 min · testflight, app-store-connect, bundle-id, provisioning, xcodegen
    • 03
      Signing and Uploading With Nobody at the Keyboard~16 min · testflight, signing, app-store-connect-api, keychain, automation
    • 04
      Build Numbers: At the Source, Committed Last, Under a Rolling Cap~15 min · testflight, build-numbers, xcodegen, versioning, upload-limits
    • 05
      Archive, Export, Upload: One Command That Cannot Lie~17 min · testflight, xcodebuild, export, zsh, pipelines
    • 06
      Gate the Artifact Before Apple Reads It~17 min · testflight, upload-gates, archive, app-intents, verification
    • 07
      From Processed to Installed: Reading the Last Three Facts~14 min · testflight, app-store-connect, internal-testing, verification, reporting

    ✓Quiz · 4 questions→

13. 13🔬Proof and the Fleet

    0/6 lessons

    Green is not exercised, the installed app under deadlines, reading a real device, one build shipped as verified copies, measurement over narrative, and the whole path from an empty folder

    How the family knows that what it shipped works, and says only what it knows. Why a green suite covers only what the hardware and tests exercised and a skip must never read as a pass, how an installed-app gate launches the real bundle with a deadline on every wait, how to read a TestFlight phone over the cable when a share does nothing, how one Mac builds and every other Mac receives verified copies with the right quit policy, why the start time of a process beats a plausible story, and the whole path from an empty folder to a build installed on the phone.

    Lesson list (6)

    • 01
      Green Is Not Exercised~17 min · proof-and-fleet, testing, simulator, skips, verification
    • 02
      Test the Installed App, With a Deadline on Every Wait~17 min · proof-and-fleet, installed-app, gui-testing, launchservices, deadlines
    • 03
      Read the Device, Not Your Theory~16 min · proof-and-fleet, devicectl, diagnostics, crash-logs, share-extension
    • 04
      Build Once, Ship Verified Copies to Every Mac~17 min · proof-and-fleet, deployment, fleet, rsync, codesign
    • 05
      Measure, Don't Narrate~15 min · proof-and-fleet, epistemics, diagnostics, launchd, verification
    • 06
      From an Empty Folder to a Build on the Phone~18 min · proof-and-fleet, synthesis, capstone, testflight, workflow

    ✓Quiz · 4 questions→