Performance Monitoring

Performance Monitoring & Optimization

Performance Targets

SwiftUI Optimization

Avoid Unnecessary View Updates

// Use @Observable with computed properties carefully
@Observable
final class TransactionListViewModel {
    // Only published properties trigger view updates
    var transactions: [Transaction] = []
    var isLoading = false

    // Derived state — does NOT trigger extra updates
    var totalAmount: Decimal {
        transactions.reduce(0) { $0 + $1.amount }
    }
}

Lazy Loading for Lists

// ALWAYS use LazyVStack for long lists
ScrollView {
    LazyVStack(spacing: FinanceSpacing.sm) {
        ForEach(viewModel.transactions) { transaction in
            TransactionRow(transaction: transaction)
                .id(transaction.id) // Stable identity
        }
    }
}

Reduce View Body Complexity

// Break complex views into smaller components
// BAD: One massive body
// GOOD: Composed from focused subviews
struct TransactionDetailView: View {
    var body: some View {
        ScrollView {
            headerSection
            amountSection
            categorySection
            notesSection
        }
    }

    private var headerSection: some View { /* ... */ }
    private var amountSection: some View { /* ... */ }
}

CoreData / SwiftData Query Optimization

Fetch with Limits and Predicates

// ALWAYS use predicates and limits — never fetch all then filter
let descriptor = FetchDescriptor<TransactionEntity>(
    predicate: #Predicate { $0.date >= startDate && $0.date <= endDate },
    sortBy: [SortDescriptor(\.date, order: .reverse)]
)
descriptor.fetchLimit = 50
descriptor.fetchOffset = page * 50

Background Fetching

// Heavy queries on ModelActor, not main thread
@ModelActor
actor BackgroundDataHandler {
    func fetchMonthlyReport(month: Date) throws -> MonthlyReport {
        let transactions = try modelContext.fetch(descriptor)
        return MonthlyReport(from: transactions)
    }
}

Instruments Profiling Checklist

1. Time Profiler: Identify slow functions, especially in body computations
2. SwiftUI Instruments: Check for excessive view updates
3. Allocations: Monitor memory growth, look for leaks
4. Core Data: Check fetch count, batch sizes, faulting behavior
5. Network: Monitor CloudKit sync payload sizes and frequency

OSLog for Performance Tracking

import OSLog

extension Logger {
    static let performance = Logger(subsystem: "com.app.finance", category: "Performance")
}

// Usage
func loadTransactions() async {
    let signpost = OSSignposter(logger: .performance)
    let state = signpost.beginInterval("LoadTransactions")
    defer { signpost.endInterval("LoadTransactions", state) }

    // ... load data
}

Memory Management

• Use weak references in closures capturing self
• Prefer value types (struct) to avoid retain cycles
• Use @Environment(\.dismiss) instead of storing navigation state
• Release image caches when receiving memory warnings
• Use prefetchItemsAt for collection view data prefetching