abanoub-ashraf/ios-staff-engineer

<!-- TRIGGER TOPICS (for reference - Codex matches semantically from skill content): - Roles: advanced iOS, staff engineer, senior developer, technical leadership - Swift 6: strict concurrency, region isolation, sending keyword, approachable concurrency, Sendable - iOS 26: Liquid Glass, glassEffect, glass material - Frameworks: FoundationModels, on-device AI/LLM, SwiftData inheritance, Charts 3D, AppIntents Visual Intelligence, AlarmKit, native WebView - Performance: InlineArray, Span, memory management, performance optimization - Architecture: architecture decision, system design, trade-offs, dependency injection, unidirectional data flow - Learning: how does X work under the hood, best practices, code review, prepare for senior/staff roles -->

iOS Staff Engineer Mastery

Swift Pattern Matching & Control Flow

Enum Case Matching

// if case let - match single enum case without verbose switch
if case let .success(value) = result {
    process(value)
}

// @unknown default - compiler warns on future enum cases
switch state {
case .loading: showSpinner()
case .loaded: showContent()
@unknown default: showFallback()
}

One-Sided Ranges in Switch

switch temperature {
case ..<0: return "freezing"
case 0..<20: return "cold"
case 20...: return "warm"
}

Custom Pattern Matching

// Overload ~= operator for custom matching
func ~= (pattern: ClosedRange<Int>, value: StatusCode) -> Bool {
    pattern.contains(value.code)
}

switch response.status {
case 200...299: handleSuccess()
case 400...499: handleClientError()
case 500...599: handleServerError()
default: handleUnknown()
}

Tuple Pattern Matching

// Switch on multiple values simultaneously
switch (isLoggedIn, hasSubscription) {
case (true, true): showPremiumContent()
case (true, false): showUpsell()
case (false, _): showLogin()
}

// Multiple optional values
switch (name, age) {
case let (name?, age?): print("\(name), \(age)")
case let (name?, nil): print("\(name), age unknown")
case (nil, _): print("Anonymous")
}

Advanced Optional Handling

Shorthand Syntax (Swift 5.7+)

// Before: if let value = value
if let value { process(value) }

// Modify unwrapped value directly with var
if var count = optionalCount {
    count += 1
    save(count)
}

Transform with map()

let displayName = user.name.map { "Hello, \($0)" } ?? "Hello, Guest"

Extract and Clear with take()

// Get value and set to nil atomically
if let pending = pendingRequest.take() {
    execute(pending)
}

Non-nil Loop Iteration

// Only iterate non-nil elements
for case let item? in optionalItems {
    process(item)
}

Functions & Closures

Variadic Parameters

func log(_ items: Any..., separator: String = " ") {
    print(items.map { "\($0)" }.joined(separator: separator))
}

OptionSet for Non-Exclusive Options

struct Permissions: OptionSet {
    let rawValue: Int
    static let read = Permissions(rawValue: 1 << 0)
    static let write = Permissions(rawValue: 1 << 1)
    static let execute = Permissions(rawValue: 1 << 2)
    static let all: Permissions = [.read, .write, .execute]
}

@autoclosure for Deferred Evaluation

func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String) {
    guard condition() else {
        fatalError(message()) // message only evaluated on failure
    }
}

Never Return Type

func fatalError(_ message: String) -> Never {
    print(message)
    abort()
}

Opaque Types

// Simplify generic signatures with some
func makeCollection() -> some Collection<Int> {
    [1, 2, 3]
}

Key Path as Function (Swift 5.2+)

let names = users.map(\.name)
let adults = users.filter(\.isAdult)
let sorted = users.sorted(by: \.age)

Custom Types

Custom String Representation

struct User: CustomStringConvertible, CustomDebugStringConvertible {
    let id: Int, name: String
    var description: String { name }
    var debugDescription: String { "User(id: \(id), name: \(name))" }
}

Literal Initialization

struct Email: ExpressibleByStringLiteral {
    let value: String
    init(stringLiteral value: String) { self.value = value }
}
let email: Email = "[email protected]"

Callable Types

struct Validator {
    let pattern: String
    func callAsFunction(_ input: String) -> Bool {
        input.range(of: pattern, options: .regularExpression) != nil
    }
}
let isEmail = Validator(pattern: "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}")
if isEmail("[email protected]") { print("Valid") }

Copy-on-Write Implementation

final class Storage<T> { var value: T; init(_ v: T) { value = v } }

struct COWWrapper<T> {
    private var storage: Storage<T>
    var value: T {
        get { storage.value }
        set {
            if !isKnownUniquelyReferenced(&storage) {
                storage = Storage(newValue)
            } else {
                storage.value = newValue
            }
        }
    }
}

Noncopyable Types (Swift 5.9+)

struct FileHandle: ~Copyable {
    private let fd: Int32
    
    consuming func close() {
        Darwin.close(fd)
        discard self // Suppress automatic cleanup
    }
    
    deinit { Darwin.close(fd) }
}

Recursive Enumerations

indirect enum Expression {
    case number(Int)
    case addition(Expression, Expression)
    case multiplication(Expression, Expression)
}

Property Management

Lazy Properties

class ViewController {
    lazy var heavyResource: Resource = {
        let r = Resource()
        r.configure()
        return r
    }()
}

Property Observers During Init

class Counter {
    var value: Int { didSet { print("Changed to \(value)") } }
    
    init(value: Int) {
        self.value = value
        defer { self.value = value } // Triggers didSet
    }
}

Async Property Getters

var data: Data {
    get async throws {
        try await networkService.fetch()
    }
}

Property Wrappers

@propertyWrapper
struct Clamped<T: Comparable> {
    private var value: T
    let range: ClosedRange<T>
    
    var wrappedValue: T {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }
    
    init(wrappedValue: T, _ range: ClosedRange<T>) {
        self.range = range
        self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }
}

struct Settings {
    @Clamped(0...100) var volume: Int = 50
}

Swift 6 Concurrency

Region Isolation

// Compiler tracks which region values belong to
actor Database {
    var cache: [String: Data] = [:]
    
    func get(_ key: String) -> Data? {
        cache[key] // Safe: accessing actor-isolated state
    }
}

Sending Keyword

// Explicitly mark values that cross isolation boundaries
func process(_ data: sending Data) async {
    await worker.handle(data)
}

@MainActor Isolation

@MainActor
class ViewModel: ObservableObject {
    @Published var items: [Item] = []
    
    func refresh() async {
        let newItems = await api.fetchItems()
        items = newItems // Safe: already on MainActor
    }
}

Sendable Conformance

// Value types are implicitly Sendable if all properties are Sendable
struct UserData: Sendable {
    let id: UUID
    let name: String
}

// Reference types require explicit marking
final class Config: Sendable {
    let apiKey: String // Must be immutable
    init(apiKey: String) { self.apiKey = apiKey }
}

Architecture Patterns

Dependency Injection Without Frameworks

// Environment container at app root
struct AppEnvironment {
    let api: APIClient
    let database: Database
    let analytics: Analytics
    
    static let live = AppEnvironment(
        api: LiveAPIClient(),
        database: SQLiteDatabase(),
        analytics: FirebaseAnalytics()
    )
    
    static let mock = AppEnvironment(
        api: MockAPIClient(),
        database: InMemoryDatabase(),
        analytics: NoOpAnalytics()
    )
}

// Pass through initializers, not singletons
class ViewModel {
    private let api: APIClient
    init(api: APIClient) { self.api = api }
}

Protocol Witness Pattern

// Replace protocols with structs for flexibility
struct APIClient<Response> {
    let fetch: (Request) async throws -> Response
}

extension APIClient where Response == User {
    static let live = APIClient { request in
        try await URLSession.shared.decode(User.self, from: request)
    }
    
    static let mock = APIClient { _ in
        User(id: 1, name: "Test User")
    }
}

Unidirectional Data Flow

@Observable
class Store<State, Action> {
    private(set) var state: State
    private let reducer: (inout State, Action) -> Effect<Action>
    
    func send(_ action: Action) {
        let effect = reducer(&state, action)
        Task { await processEffect(effect) }
    }
}

iOS 26 Liquid Glass

Glass Material

.background(.regularMaterial) // System glass
.glassEffect() // iOS 26 Liquid Glass

// Custom glass with tint
.background {
    Glass()
        .fill(.blue.opacity(0.1))
}

Adaptive Layouts

// Respond to glass region changes
@Environment(\.glassRegion) var glassRegion

var body: some View {
    content
        .padding(glassRegion.insets)
}

Performance Optimization

Avoiding Retain Cycles

class NetworkManager {
    func fetch(completion: @escaping (Result<Data, Error>) -> Void) {
        task = session.dataTask(with: url) { [weak self] data, _, error in
            guard let self else { return }
            self.process(data, error, completion)
        }
    }
}

Collection Performance

// reserveCapacity for known sizes
var items: [Item] = []
items.reserveCapacity(1000)

// Use ContiguousArray for better cache locality
var values = ContiguousArray<Int>()

// Lazy sequences for chained operations
let result = items
    .lazy
    .filter { $0.isValid }
    .map { $0.transformed }
    .prefix(10)

String Optimization

// Use Substring to avoid copies
let input = "Hello, World!"
let firstWord = input.prefix(while: { $0 != "," }) // Substring, no copy

// Convert to String only when needed for storage
let stored = String(firstWord)

Testing Strategies

Test at Integration Level

// Mock at network boundary, not every dependency
class APIClientTests: XCTestCase {
    func testFetchUser() async throws {
        let mockSession = MockURLSession()
        mockSession.data = userData
        
        let client = APIClient(session: mockSession)
        let user = try await client.fetchUser(id: 1)
        
        XCTAssertEqual(user.name, "Test")
    }
}

Async Testing

func testAsyncOperation() async throws {
    let viewModel = ViewModel()
    await viewModel.refresh()
    
    // Use expectations for callbacks
    let expectation = expectation(description: "completion")
    viewModel.onComplete = { expectation.fulfill() }
    await fulfillment(of: [expectation], timeout: 5)
}

Code Review Checklist

Memory: Weak references in closures? Retain cycles avoided? Large allocations lazy?

Concurrency: MainActor for UI updates? Sendable conformance correct? Data races impossible?

Error Handling: All throws handled? User-facing errors localized? Recovery paths exist?

Performance: O(n²) operations flagged? Unnecessary copies avoided? Lazy evaluation where appropriate?

API Design: Clear naming? Progressive disclosure? Impossible states unrepresentable?

---

iOS 26 / WWDC 2025 New Frameworks

Deep Dive: See references/ios26-new-frameworks.md for comprehensive coverage.

FoundationModels (On-Device AI)

import FoundationModels

// Check availability
guard SystemLanguageModel.default.isAvailable else { return }

// Create session and generate
let session = LanguageModelSession()
let response = try await session.respond(to: "Explain Swift concurrency")

// Structured output with @Generable
@Generable
struct Summary {
    @Guide("Main topic")
    let topic: String
    @Guide("Key points")
    let points: [String]
}

let summary: Summary = try await session.respond(
    to: "Summarize this article",
    generating: Summary.self
)

// Tool calling
@Toolable
struct SearchTool {
    func search(query: String) async -> [Result] { ... }
}
let session = LanguageModelSession(tools: [SearchTool()])

SwiftData Class Inheritance

// Base model
@Model
class MediaItem {
    var title: String
    var rating: Double
}

// Subclasses
@Model
final class Movie: MediaItem {
    var director: String
}

@Model
final class TVShow: MediaItem {
    var seasons: Int
}

// Polymorphic queries
@Query var allMedia: [MediaItem]  // Returns both Movies and TVShows
@Query var movies: [Movie]         // Only Movies

// Type-based predicates
let descriptor = FetchDescriptor<MediaItem>(
    predicate: #Predicate { $0 is Movie && $0.rating > 8.0 }
)

Swift Charts 3D

import Charts

// 3D Surface Plot
Chart3D {
    SurfacePlot(data) { point in
        PlotPoint3D(x: point.x, y: point.y, z: point.z)
    }
    .foregroundStyle(.blue.gradient)
}
.chart3DPose($pose)  // Enable rotation gestures

// Mathematical surface
Chart3D {
    SurfacePlot(x: -10...10, y: -10...10) { x, y in
        sin(sqrt(x * x + y * y))
    }
}

InlineArray & Span

// Fixed-size stack-allocated array
var buffer: InlineArray<Int, 16> = .init(repeating: 0)
buffer[0] = 42

// Safe memory view without copying
array.withSpan { span in
    for value in span { process(value) }
    let slice = span[0..<10]  // Zero-copy slice
}

AlarmKit

import AlarmKit

let manager = AlarmManager()
await manager.requestAuthorization()

let alarm = AlarmPresentation(
    title: "Workout",
    scheduledTime: DateComponents(hour: 6, minute: 30),
    repeatSchedule: .weekdays
)
try await manager.schedule(alarm)

Native WebView

import SwiftUI

struct BrowserView: View {
    @State private var page = WebPage()

    var body: some View {
        VStack {
            HStack {
                Button("Back") { page.goBack() }
                    .disabled(!page.canGoBack)
                if page.isLoading { ProgressView() }
            }
            WebView(page: page)
        }
        .onAppear { page.load(URL(string: "https://apple.com")!) }
    }
}

// JavaScript execution
let title = try await page.evaluateJavaScript("document.title")

AppIntents Visual Intelligence

// Visual context queries
struct IdentifyItemIntent: AppIntent {
    @Parameter var imageQuery: IntentValueQuery<ItemInfo>

    func perform() async throws -> some IntentResult {
        let item = try await imageQuery.value
        return .result(value: item.description)
    }
}

// Execution modes
static var executionMode: IntentExecutionMode = .background
static var executionMode: IntentExecutionMode { .foreground(.dynamic) }

// Computed properties
@ComputedProperty var total: Decimal { items.reduce(0) { $0 + $1.price } }

Enhanced Toolbar APIs

// Customizable toolbar with IDs
.toolbar(id: "editor") {
    ToolbarItem(id: "bold") { Button("Bold") { } }
    ToolbarSpacer(id: "spacer")
    ToolbarItem(id: "color") { ColorPicker("Color", selection: $color) }
}

// Search behavior
.searchable(text: $query)
.searchToolbarBehavior(.minimize)  // Collapse when not focused

AttributedString Enhancements

var text = AttributedString("Styled Text")
text.textAlignment = .center
text.lineHeight = .multiplier(1.5)

// Selection-based editing
@State var selection = AttributedTextSelection()
TextEditor(text: $text, selection: $selection)
    .toolbar {
        Button("Bold") {
            text.transformAttributes(in: selection.range) { $0.font = .bold }
        }
    }

Assistive Access

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup { ContentView() }

        AssistiveAccess { SimplifiedView() }  // Simplified UI
    }
}

// Adapt to mode
@Environment(\.assistiveAccessEnabled) var isAssistiveAccess
if isAssistiveAccess {
    LargeSimplifiedUI()
}

visionOS Widgets

// Mounting styles
.mountingStyle(.elevated)  // Float above surfaces
.mountingStyle(.recessed)  // Sit into surfaces

// Textures
.widgetTexture(.glass)
.widgetTexture(.paper)

// Level of detail
@Environment(\.levelOfDetail) var detail
switch detail {
case .full: FullView()
case .reduced: SimpleView()
}