Performance Optimization — Expert Decisions

Expert decision frameworks for performance choices. Claude knows lazy loading and async basics — this skill provides judgment calls for when to optimize and which tool to use.

Decision Trees

Should You Optimize?

When should you invest in optimization? ├─ User-facing latency issue (visible stutter/delay) │ └─ YES — Profile and fix │ Measure first, optimize second │ ├─ Premature concern ("this might be slow") │ └─ NO — Wait for evidence │ Write clean code, profile later │ ├─ Battery drain complaints │ └─ YES — Use Energy Diagnostics │ Focus on background work, location, network │ ├─ Memory warnings / crashes │ └─ YES — Use Allocations + Leaks │ Find retain cycles, unbounded caches │ └─ App store reviews mention slowness └─ YES — Profile real scenarios User perception matters

The trap: Optimizing based on assumptions. Always profile first. The bottleneck is rarely where you think.

Profiling Tool Selection

What are you measuring? ├─ Slow UI / frame drops │ └─ Time Profiler + View Debugger │ Find expensive work on main thread │ ├─ Memory growth / leaks │ └─ Allocations + Leaks instruments │ Track object lifetimes, find cycles │ ├─ Network performance │ └─ Network instrument + Charles/Proxyman │ Latency, payload size, request count │ ├─ Disk I/O issues │ └─ File Activity instrument │ Excessive reads/writes │ ├─ Battery drain │ └─ Energy Log instrument │ CPU wake, location, networking │ └─ GPU / rendering └─ Core Animation instrument Offscreen rendering, overdraw

SwiftUI View Update Strategy

View is re-rendering too often? ├─ Caused by parent state changes │ └─ Extract to separate view │ Child doesn't depend on changing state │ ├─ Complex computed body │ └─ Cache expensive computations │ Use ViewModel or memoization │ ├─ List items all updating │ └─ Check view identity │ Use stable IDs, not indices │ ├─ Observable causing cascading updates │ └─ Split into multiple @Published │ Or use computed properties │ └─ Animation causing constant redraws └─ Use drawingGroup() or limit scope Rasterize stable content

Memory Management Decision

How to fix memory issues? ├─ Steady growth during use │ └─ Check caches and collections │ Add eviction, use NSCache │ ├─ Growth tied to navigation │ └─ Check retain cycles │ weak self in closures, delegates │ ├─ Large spikes on specific screens │ └─ Downsample images │ Load at display size, not full resolution │ ├─ Memory not released after screen dismissal │ └─ Debug object lifecycle │ deinit not called = retain cycle │ └─ Background memory pressure └─ Respond to didReceiveMemoryWarning Clear caches, release non-essential data

NEVER Do

View Identity

NEVER use indices as identifiers:

// ❌ Identity changes when array mutates List(items.indices, id: .self) { index in ItemRow(item: items[index]) } // Insert at index 0 → all views recreated!

// ✅ Use stable identifiers List(items) { item in ItemRow(item: item) .id(item.id) // Stable across mutations }

NEVER compute expensive values in body:

// ❌ Called on every render var body: some View { let sortedItems = items.sorted { $0.date > $1.date } // O(n log n) per render! let filtered = sortedItems.filter { $0.isActive }

List(filtered) { item in
    ItemRow(item: item)
}

}

// ✅ Compute in ViewModel or use computed property @MainActor class ViewModel: ObservableObject { @Published var items: [Item] = []

var displayItems: [Item] {
    items.filter(\.isActive).sorted { $0.date > $1.date }
}

}

State Management

NEVER use @StateObject for passed objects:

// ❌ Creates new instance on every parent update struct ChildView: View { @StateObject var viewModel: ChildViewModel // Wrong!

var body: some View { ... }

}

// ✅ Use @ObservedObject for passed objects struct ChildView: View { @ObservedObject var viewModel: ChildViewModel // Parent owns it

var body: some View { ... }

}

NEVER make everything @Published:

// ❌ Every property change triggers view updates class ViewModel: ObservableObject { @Published var items: [Item] = [] @Published var internalCache: [String: Data] = [:] // UI doesn't need this! @Published var isProcessing = false // Maybe internal only }

// ✅ Only publish what UI observes class ViewModel: ObservableObject { @Published var items: [Item] = [] @Published var isLoading = false

private var internalCache: [String: Data] = [:]  // Not @Published
private var isProcessing = false  // Private state

}

Memory Leaks

NEVER capture self strongly in escaping closures:

// ❌ Retain cycle — never deallocates class ViewModel { var timer: Timer?

func start() {
    timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
        self.tick()  // Strong capture!
    }
}

}

// ✅ Weak capture + invalidation class ViewModel { var timer: Timer?

func start() {
    timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
        self?.tick()
    }
}

deinit {
    timer?.invalidate()
}

}

NEVER forget to remove observers:

// ❌ Leaks observer and potentially self class ViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() NotificationCenter.default.addObserver( self, selector: #selector(handleNotification), name: .userLoggedIn, object: nil ) // Never removed! } }

// ✅ Remove in deinit or use modern API class ViewController: UIViewController { private var observer: NSObjectProtocol?

override func viewDidLoad() {
    super.viewDidLoad()
    observer = NotificationCenter.default.addObserver(
        forName: .userLoggedIn,
        object: nil,
        queue: .main
    ) { [weak self] _ in
        self?.handleNotification()
    }
}

deinit {
    if let observer { NotificationCenter.default.removeObserver(observer) }
}

}

Image Loading

NEVER load full resolution for thumbnails:

// ❌ 4000×3000 image for 80×80 thumbnail let image = UIImage(contentsOfFile: path) // Full resolution in memory! imageView.image = image

// ✅ Downsample to display size func downsampledImage(at url: URL, to size: CGSize) -> UIImage? { let options: [CFString: Any] = [ kCGImageSourceShouldCache: false, kCGImageSourceCreateThumbnailFromImageAlways: true, kCGImageSourceThumbnailMaxPixelSize: max(size.width, size.height) * UIScreen.main.scale ]

guard let source = CGImageSourceCreateWithURL(url as CFURL, nil),
      let cgImage = CGImageSourceCreateThumbnailAtIndex(source, 0, options as CFDictionary) else {
    return nil
}
return UIImage(cgImage: cgImage)

}

NEVER cache images without limits:

// ❌ Unbounded memory growth class ImageLoader { private var cache: [URL: UIImage] = [:] // Grows forever!

func image(for url: URL) -> UIImage? {
    if let cached = cache[url] { return cached }
    let image = loadImage(url)
    cache[url] = image  // Never evicted
    return image
}

}

// ✅ Use NSCache with limits class ImageLoader { private let cache = NSCache<NSURL, UIImage>()

init() {
    cache.countLimit = 100
    cache.totalCostLimit = 50 * 1024 * 1024  // 50 MB
}

func image(for url: URL) -> UIImage? {
    if let cached = cache.object(forKey: url as NSURL) { return cached }
    guard let image = loadImage(url) else { return nil }
    cache.setObject(image, forKey: url as NSURL, cost: image.jpegData(compressionQuality: 1)?.count ?? 0)
    return image
}

}

Heavy Operations

NEVER do heavy work on main thread:

// ❌ UI frozen during processing func loadData() { let data = try! Data(contentsOf: largeFileURL) // Blocks main thread! let parsed = parseData(data) // Still blocking! self.items = parsed }

// ✅ Use background thread, update on main func loadData() async { let items = await Task.detached(priority: .userInitiated) { let data = try! Data(contentsOf: largeFileURL) return parseData(data) }.value

await MainActor.run {
    self.items = items
}

}

Essential Patterns

Efficient List View

struct EfficientListView: View { let items: [Item]

var body: some View {
    ScrollView {
        LazyVStack(spacing: 12) {  // Lazy = on-demand creation
            ForEach(items) { item in
                ItemRow(item: item)
                    .id(item.id)  // Stable identity
            }
        }
    }
}

}

// Equatable row prevents unnecessary updates struct ItemRow: View, Equatable { let item: Item

var body: some View {
    HStack {
        AsyncImage(url: item.imageURL) { image in
            image.resizable().aspectRatio(contentMode: .fill)
        } placeholder: {
            Color.gray.opacity(0.3)
        }
        .frame(width: 60, height: 60)
        .clipShape(RoundedRectangle(cornerRadius: 8))

        VStack(alignment: .leading) {
            Text(item.title).font(.headline)
            Text(item.subtitle).font(.caption).foregroundColor(.secondary)
        }
    }
}

static func == (lhs: ItemRow, rhs: ItemRow) -> Bool {
    lhs.item.id == rhs.item.id &&
    lhs.item.title == rhs.item.title &&
    lhs.item.subtitle == rhs.item.subtitle
}

}

Memory-Safe ViewModel

@MainActor final class ViewModel: ObservableObject { @Published private(set) var items: [Item] = [] @Published private(set) var isLoading = false

private var cancellables = Set<AnyCancellable>()
private var loadTask: Task<Void, Never>?

func load() {
    loadTask?.cancel()  // Cancel previous

    loadTask = Task {
        guard !Task.isCancelled else { return }

        isLoading = true
        defer { isLoading = false }

        do {
            let items = try await API.fetchItems()
            guard !Task.isCancelled else { return }
            self.items = items
        } catch {
            // Handle error
        }
    }
}

deinit {
    loadTask?.cancel()
    cancellables.removeAll()
}

}

Debounced Search

@MainActor final class SearchViewModel: ObservableObject { @Published var searchText = "" @Published private(set) var results: [Item] = []

private var searchTask: Task<Void, Never>?

init() {
    // Debounce search
    $searchText
        .debounce(for: .milliseconds(300), scheduler: DispatchQueue.main)
        .removeDuplicates()
        .sink { [weak self] text in
            self?.performSearch(text)
        }
        .store(in: &cancellables)
}

private func performSearch(_ query: String) {
    searchTask?.cancel()

    guard !query.isEmpty else {
        results = []
        return
    }

    searchTask = Task {
        do {
            let results = try await API.search(query: query)
            guard !Task.isCancelled else { return }
            self.results = results
        } catch {
            // Handle error
        }
    }
}

}

Quick Reference

Instruments Selection

Issue Instrument What to Look For

Slow UI Time Profiler Heavy main thread work

Memory leak Leaks Leaked objects

Memory growth Allocations Growing categories

Battery Energy Log Wake frequency

Network Network Request count, size

Disk File Activity Excessive I/O

GPU Core Animation Offscreen renders

SwiftUI Performance Checklist

Issue Solution

Slow list scrolling Use LazyVStack/LazyVGrid

All items re-render Stable IDs, Equatable rows

Heavy body computation Move to ViewModel

Cascading @Published updates Split or use computed

Animation jank Use drawingGroup()

Memory Management

Pattern Prevent Issue

[weak self] in closures Retain cycles

Timer.invalidate() in deinit Timer leaks

Remove observers in deinit Observer leaks

NSCache with limits Unbounded cache growth

Image downsampling Memory spikes

os_signpost for Custom Profiling

import os.signpost

let log = OSLog(subsystem: "com.app", category: .pointsOfInterest)

os_signpost(.begin, log: log, name: "DataProcessing") // Expensive work os_signpost(.end, log: log, name: "DataProcessing")

Red Flags

Smell Problem Fix

Indices as List IDs Views recreated on mutation Use stable identifiers

Expensive body computation Runs every render Move to ViewModel

@StateObject for passed object Creates new instance Use @ObservedObject

Strong self in Timer/closure Retain cycle Use [weak self]

Full-res images for thumbnails Memory explosion Downsample to display size

Unbounded dictionary cache Memory growth Use NSCache with limits

Heavy work without Task.detached Blocks main thread Use background priority