App Store Guidelines

Pre-Submission Checklist

Privacy and permissions

• Add NSCameraUsageDescription to Info.plist if using camera
• Add NSPhotoLibraryUsageDescription if accessing photo library
• Add NSLocationWhenInUseUsageDescription or NSLocationAlwaysAndWhenInUseUsageDescription for location
• Add NSMicrophoneUsageDescription if recording audio
• Add NSContactsUsageDescription if accessing contacts
• Add NSCalendarsUsageDescription if accessing calendar
• Add NSUserTrackingUsageDescription for App Tracking Transparency
• All purpose strings must clearly explain WHY the permission is needed (not just "we need camera access")
• Implement ATTrackingManager.requestTrackingAuthorization BEFORE any tracking or ad SDK initialization
• Complete the App Privacy section in App Store Connect (data collection declarations)

Authentication

• If the app offers third-party login (Google, Facebook), also offer Sign in with Apple
• Sign in with Apple must be presented as a prominently displayed option
• Guest access should be available where reasonable (content browsing)
• Login-required apps must provide demo credentials in the review notes

In-App Purchases

• All digital goods and services must use Apple's In-App Purchase system
• Physical goods and services (Uber rides, food delivery) may use external payment
• Provide a "Restore Purchases" button for non-consumable IAPs and subscriptions
• Clearly display subscription terms, pricing, and renewal info before purchase
• Use StoreKit 2 for new implementations
• Handle receipt validation server-side for production apps
• Never reference external purchasing methods for digital content

Content and behavior

• App must function as described in metadata - no hidden features
• No placeholder content (lorem ipsum, test data, dummy screenshots)
• App must be fully functional without requiring additional purchases to be usable
• User-generated content apps must have reporting and blocking mechanisms
• Apps with age-restricted content must implement age gating
• No misleading screenshots or app previews

Technical requirements

• Runs without crashing on the declared minimum iOS version
• Supports all screen sizes for the declared device families (iPhone, iPad)
• IPv6-only network compatibility (no hardcoded IPv4 addresses)
• Does not use private APIs or undocumented frameworks
• App size is reasonable (keep under 200MB for cellular downloads)
• Background modes declared in Info.plist match actual background usage
• No excessive battery, memory, or CPU usage

Metadata

• App name does not include generic terms like "best", "#1", or competitor names
• Description accurately reflects app functionality
• Keywords are relevant (no competitor names or misleading terms)
• Screenshots show actual app UI (no marketing overlays that obscure functionality)
• Privacy policy URL is valid and accessible
• Support URL is valid and leads to a support mechanism
• Age rating is set correctly based on content

---

Common Rejection Reasons

Guideline 2.1 - Performance: App Completeness

Cause: App crashes, has placeholder content, or features don't work.

Fix:

• Test every flow on the minimum supported iOS version on a real device
• Remove all debug/test UI and placeholder content
• Ensure all buttons and links lead somewhere functional

Guideline 2.3.3 - Performance: Screenshots

Cause: Screenshots don't match the actual app or show a device frame with wrong device type.

Fix:

• Use actual app screenshots taken on the current UI
• Match screenshot device to the upload slot (iPhone 6.7" for iPhone 15 Pro Max, etc.)

Guideline 3.1.1 - Business: In-App Purchase

Cause: Using external payment for digital goods or not offering IAP for premium features.

Fix:

• All digital content, subscriptions, and premium features must use StoreKit
• Physical goods/services are exempt

Guideline 4.0 - Design: Minimum Functionality

Cause: App is too simple, wraps a website, or is a trivial modification of a template.

Fix:

• Add native functionality beyond what a web app provides
• Include meaningful features that justify a native app

Guideline 5.1.1 - Legal: Privacy - Data Collection

Cause: Missing privacy purpose strings, tracking without ATT prompt, or incomplete privacy declarations.

Fix:

• Add descriptive purpose strings for every permission
• Request ATT before any tracking
• Complete all data collection declarations in App Store Connect

Guideline 5.1.2 - Legal: Privacy - Data Use and Sharing

Cause: App collects data not disclosed in the privacy label, or shares data without consent.

Fix:

• Audit all SDKs and analytics for data collection
• Declare everything in the privacy nutrition labels
• Provide opt-out mechanisms where applicable

---

TestFlight

Internal testing

• Up to 100 internal testers (members of your App Store Connect team)
• No review required
• Builds available immediately after processing

External testing

• Up to 10,000 external testers
• First build of each version requires Beta App Review (usually < 24 hours)
• Subsequent builds of the same version are usually auto-approved
• Testers join via public link or email invitation
• Builds expire after 90 days

Best practices

• Include meaningful "What to Test" notes for each build
• Use test groups to segment testers by feature or risk level
• Monitor crash reports and feedback in App Store Connect
• Remove testers who are not actively testing

---

App Store Connect Submission Flow

1. Archive the app in Xcode (Product -> Archive)
2. Upload via Xcode Organizer or xcodebuild -exportArchive
3. Configure in App Store Connect: screenshots, description, keywords, pricing
4. Submit for review - typical review time is 24-48 hours
5. Respond to any rejection with specific fixes in the Resolution Center

Expedited review

Available for critical bug fixes. Request through the Apple developer contact form. Include:

• Detailed description of the critical issue
• Steps to reproduce
• Business impact explanation
• Expected timeline for fix

Use sparingly - Apple tracks expedited review requests and may deny frequent requesters.

Core Data Guide

Stack Architecture

NSPersistentContainer
  |
  +-- NSPersistentStoreCoordinator
  |     |
  |     +-- NSPersistentStore (SQLite, In-Memory, etc.)
  |
  +-- viewContext (NSManagedObjectContext - main queue)
  |
  +-- newBackgroundContext() (NSManagedObjectContext - private queue)

Standard setup

class PersistenceController {
    static let shared = PersistenceController()

    let container: NSPersistentContainer

    init(inMemory: Bool = false) {
        container = NSPersistentContainer(name: "DataModel")

        if inMemory {
            container.persistentStoreDescriptions.first?.url = URL(fileURLWithPath: "/dev/null")
        }

        container.loadPersistentStores { description, error in
            if let error {
                fatalError("Core Data store failed to load: \(error.localizedDescription)")
            }
        }

        container.viewContext.automaticallyMergesChangesFromParent = true
        container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
    }
}

---

Model Design

Entity attributes

Swift type	Core Data type	Notes
String	String
Int16/32/64	Integer 16/32/64	Use Int64 for most cases
Double	Double
Bool	Boolean
Date	Date
Data	Binary Data	Enable "Allows External Storage" for > 100KB
UUID	UUID	Good for unique identifiers
URL	URI	Stored as string internally

Relationships

• To-one: Optional by default; set delete rule appropriately
• To-many: Returns NSSet; use generated accessors or NSOrderedSet
• Always set inverse relationships - Core Data uses them for graph consistency

Delete rules

Rule	Behavior
Nullify	Set inverse to nil (default, safest)
Cascade	Delete related objects (parent deletes children)
Deny	Prevent deletion if relationships exist
No Action	Do nothing (can leave orphans - avoid)

---

Fetch Requests

Basic fetch

let request = NSFetchRequest<Item>(entityName: "Item")
request.predicate = NSPredicate(format: "isCompleted == %@", NSNumber(value: false))
request.sortDescriptors = [NSSortDescriptor(keyPath: \Item.createdAt, ascending: false)]
request.fetchLimit = 50

let items = try context.fetch(request)

Common predicates

// String matching
NSPredicate(format: "name CONTAINS[cd] %@", searchText)

// Date range
NSPredicate(format: "createdAt >= %@ AND createdAt <= %@", startDate as CVarArg, endDate as CVarArg)

// Relationship
NSPredicate(format: "category.name == %@", "Books")

// In set
NSPredicate(format: "status IN %@", ["active", "pending"])

// Compound
NSCompoundPredicate(andPredicateWithSubpredicates: [predicate1, predicate2])

Performance optimization

• Use fetchBatchSize (typically 20-50) to reduce memory for large result sets
• Use propertiesToFetch to load only needed attributes (partial faulting)
• Use NSAsynchronousFetchRequest for fetches that might take > 100ms
• Use NSFetchedResultsController for table/collection view data sources
• Avoid fetching in loops - batch operations instead

request.fetchBatchSize = 20
request.propertiesToFetch = ["name", "createdAt"]
request.returnsObjectsAsFaults = true  // default, loads data on access

@FetchRequest in SwiftUI

struct ItemListView: View {
    @FetchRequest(
        sortDescriptors: [SortDescriptor(\.createdAt, order: .reverse)],
        predicate: NSPredicate(format: "isCompleted == false"),
        animation: .default
    )
    private var items: FetchedResults<Item>

    var body: some View {
        List(items) { item in
            Text(item.name ?? "Untitled")
        }
    }
}

---

Background Operations

Writing on a background context

func importItems(_ data: [ItemData]) {
    let context = PersistenceController.shared.container.newBackgroundContext()
    context.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy

    context.perform {
        for itemData in data {
            let item = Item(context: context)
            item.name = itemData.name
            item.createdAt = Date()
        }

        do {
            try context.save()
        } catch {
            context.rollback()
            print("Background save failed: \(error)")
        }
    }
}

Batch operations (iOS 13+)

For large imports/updates, use batch operations that bypass the object graph:

// Batch insert
let batchInsert = NSBatchInsertRequest(entityName: "Item",
    managedObjectHandler: { object in
        guard let item = object as? Item else { return true }
        // configure item from your data source
        return false  // return true when done
    })
batchInsert.resultType = .objectIDs
let result = try context.execute(batchInsert) as? NSBatchInsertResult

// Merge changes into viewContext
if let objectIDs = result?.result as? [NSManagedObjectID] {
    NSManagedObjectContext.mergeChanges(
        fromRemoteContextSave: [NSInsertedObjectsKey: objectIDs],
        into: [container.viewContext]
    )
}

// Batch delete
let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: "Item")
fetchRequest.predicate = NSPredicate(format: "isArchived == true")
let batchDelete = NSBatchDeleteRequest(fetchRequest: fetchRequest)
batchDelete.resultType = .resultTypeObjectIDs
try context.execute(batchDelete)

---

Thread Safety Rules

1. Never pass NSManagedObject across threads - use objectID and re-fetch
2. Always use perform {} or performAndWait {} for context operations
3. viewContext is main-queue only - access only from the main thread
4. Background contexts are private-queue - only access inside perform {}
5. Set automaticallyMergesChangesFromParent = true on viewContext to see background saves

// Safe: pass objectID across threads
let objectID = item.objectID

context.perform {
    let item = context.object(with: objectID) as! Item
    item.name = "Updated"
    try? context.save()
}

---

Migrations

Lightweight migration (automatic)

Core Data handles these automatically when you add the migration options:

let description = NSPersistentStoreDescription()
description.shouldMigrateStoreAutomatically = true
description.shouldInferMappingModelAutomatically = true

Supported lightweight changes:

• Add/remove attributes (with default values for non-optional new attributes)
• Add/remove entities
• Rename entities/attributes (set renaming identifier in model editor)
• Change relationship cardinality
• Add/remove relationships

Custom migration

For changes that exceed lightweight migration (transforming data, splitting entities):

1. Create a new model version in Xcode (Editor -> Add Model Version)
2. Create an NSMappingModel with custom NSEntityMigrationPolicy subclasses
3. Implement createDestinationInstances(forSource:in:manager:) for data transformation

---

CloudKit Sync (NSPersistentCloudKitContainer)

let container = NSPersistentCloudKitContainer(name: "DataModel")

let description = container.persistentStoreDescriptions.first!
description.cloudKitContainerOptions = NSPersistentCloudKitContainerOptions(
    containerIdentifier: "iCloud.com.yourapp.container"
)

container.loadPersistentStores { _, error in
    if let error { fatalError("CloudKit store failed: \(error)") }
}

container.viewContext.automaticallyMergesChangesFromParent = true
container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy

Key considerations:

• All attributes must be optional (CloudKit requirement)
• Unique constraints are not supported with CloudKit
• Relationships must have inverses
• Monitor sync status with NSPersistentCloudKitContainer.eventChangedNotification
• Test with real iCloud accounts on devices, not Simulator

Performance Tuning

Instruments Workflows

Time Profiler

Use to find CPU bottlenecks - functions consuming the most time.

1. Profile on a real device (Product -> Profile or Cmd+I)
2. Select the Time Profiler template
3. Record while reproducing the slow behavior
4. Sort by "Self Weight" to find hotspots
5. Uncheck "Separate by Thread" to see overall impact
6. Check "Invert Call Tree" to see leaf functions first
7. Double-click to jump to source code

Common findings:

• JSON decoding on the main thread
• Image resizing/decoding synchronously
• Complex view layout calculations
• String processing in tight loops

Allocations

Use to find memory issues - objects that grow without bound.

1. Select the Allocations template
2. Record while exercising the suspected flow
3. Use "Mark Generation" between navigation actions
4. Growth between generations reveals leaks or unbounded caches
5. Filter by your app's class names to focus on your code

Look for:

• Generations that only grow (never shrink) - memory leak
• Large image allocations not released after dismissal
• Retained view controllers after navigation back

Leaks

Use alongside Allocations to find retain cycles.

1. Select the Leaks template
2. Exercise the app (push/pop screens, open/close features)
3. Leaks instrument will flag leaked objects
4. Inspect the retain cycle in the cycle graph

Common retain cycles:

• Closure capturing self strongly
• Delegate not declared as weak
• Timer retaining its target
• NotificationCenter observers with strong references

Core Animation (Rendering)

Use to find rendering performance issues (dropped frames, hitches).

1. Select the Core Animation template (or use "Animation Hitches" in newer Xcode)
2. Look for frames exceeding 16.67ms (60fps) or 8.33ms (120fps on ProMotion)
3. Enable "Color Blended Layers" - red areas indicate alpha blending overhead
4. Enable "Color Offscreen-Rendered" - yellow areas indicate expensive offscreen passes

Common fixes:

• Set layer.shouldRasterize = true for complex static views (with correct rasterizationScale)
• Avoid clipsToBounds + cornerRadius on frequently redrawn views (use a mask layer instead)
• Pre-decode images to the display size with UIGraphicsImageRenderer
• Use opaque backgrounds where possible to reduce blending

---

Memory Optimization

Image handling

Images are the largest memory consumers in most iOS apps.

// Bad: loads full-resolution image into memory
let image = UIImage(named: "hero")

// Good: downsample to display size
func downsample(imageAt url: URL, to pointSize: CGSize, scale: CGFloat) -> UIImage? {
    let maxDimensionInPixels = max(pointSize.width, pointSize.height) * scale
    let options: [CFString: Any] = [
        kCGImageSourceCreateThumbnailFromImageAlways: true,
        kCGImageSourceShouldCacheImmediately: true,
        kCGImageSourceCreateThumbnailWithTransform: true,
        kCGImageSourceThumbnailMaxPixelSize: maxDimensionInPixels
    ]

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

    return UIImage(cgImage: cgImage)
}

Memory budget guidelines

Device	Safe memory ceiling
2GB RAM (iPhone SE 3)	~600MB
4GB RAM (iPhone 14)	~1.2GB
6GB RAM (iPhone 15 Pro)	~2GB

Exceeding these thresholds risks jetsam termination (system kills your app). Monitor with os_proc_available_memory().

Autorelease pool optimization

// When creating many temporary objects in a loop
for imageURL in urls {
    autoreleasepool {
        let image = processImage(at: imageURL)
        saveProcessedImage(image)
    }
}

---

Launch Time Optimization

Target: < 400ms for warm launch. Apple considers > 2 seconds unacceptable.

Measurement

// In your app delegate or @main struct
// Xcode shows pre-main time in the environment variable
// DYLD_PRINT_STATISTICS = 1

Use the App Launch template in Instruments for detailed breakdown.

Pre-main optimizations

• Reduce embedded frameworks (each framework adds ~10-30ms)
• Remove unused code and frameworks
• Avoid +load and +initialize methods in Objective-C code
• Minimize static initializers

Post-main optimizations

• Defer non-essential work past first frame render
• Load Core Data store asynchronously
• Defer analytics SDK initialization
• Use lazy initialization for heavy objects
• Prefetch critical data but don't block the main thread

@main
struct MyApp: App {
    init() {
        // Only essential setup here
        configureAppearance()
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
                .task {
                    // Deferred initialization
                    await initializeAnalytics()
                    await prefetchUserData()
                }
        }
    }
}

---

SwiftUI Performance

Reducing view re-evaluations

// Use @Observable for fine-grained updates (iOS 17+)
@Observable
class ViewModel {
    var title = ""
    var items: [Item] = []
    var isLoading = false
}

// Only views reading `title` re-evaluate when title changes
// Views reading `items` are unaffected

Lazy containers

// Always use Lazy variants for large collections
ScrollView {
    LazyVStack(spacing: 8) {
        ForEach(items) { item in
            ItemRow(item: item)
        }
    }
}

Identifying views correctly

// Bad: using index as id causes full re-render on changes
ForEach(Array(items.enumerated()), id: \.offset) { ... }

// Good: use stable identifier
ForEach(items) { item in  // Item conforms to Identifiable
    ItemRow(item: item)
}

Avoiding unnecessary work

// Cache formatted values
struct ItemRow: View {
    let item: Item

    // Computed once per evaluation, not per render
    private var formattedPrice: String {
        item.price.formatted(.currency(code: "USD"))
    }

    var body: some View {
        Text(formattedPrice)
    }
}

---

Energy Efficiency

Battery drain causes negative App Store reviews. Profile with the Energy Log instrument.

Best practices

• Use BGTaskScheduler for background work, not continuous background execution
• Batch network requests instead of many small calls
• Stop location updates when not needed (locationManager.stopUpdatingLocation())
• Use significant location changes (startMonitoringSignificantLocationChanges()) when precise tracking is unnecessary
• Reduce GPS accuracy when high precision is not required
• Stop timers when views disappear
• Use URLSession background transfers for large downloads
• Avoid polling - use push notifications or server-sent events

Networking efficiency

// Batch requests with TaskGroup
func fetchAllData() async throws -> (users: [User], posts: [Post]) {
    async let users = fetchUsers()
    async let posts = fetchPosts()
    return try await (users, posts)
}

// Use URLCache effectively
let config = URLSessionConfiguration.default
config.urlCache = URLCache(
    memoryCapacity: 20 * 1024 * 1024,   // 20 MB memory
    diskCapacity: 100 * 1024 * 1024      // 100 MB disk
)
config.requestCachePolicy = .returnCacheDataElseLoad

SwiftUI Patterns

Navigation (iOS 16+)

NavigationStack

NavigationStack replaces NavigationView and supports value-based, programmatic navigation.

@State private var path = NavigationPath()

NavigationStack(path: $path) {
    List(items) { item in
        NavigationLink(value: item) {
            Text(item.name)
        }
    }
    .navigationDestination(for: Item.self) { item in
        ItemDetailView(item: item)
    }
}

// Programmatic navigation
path.append(someItem)     // push
path.removeLast()         // pop
path = NavigationPath()   // pop to root

TabView

TabView {
    Tab("Home", systemImage: "house") {
        HomeView()
    }
    Tab("Settings", systemImage: "gear") {
        SettingsView()
    }
}

Sheet and fullScreenCover

@State private var showSheet = false

Button("Show") { showSheet = true }
    .sheet(isPresented: $showSheet) {
        DetailView()
    }

// For item-based presentation
.sheet(item: $selectedItem) { item in
    DetailView(item: item)
}

---

State Management

Property wrapper decision tree

Wrapper	Ownership	Use when
@State	View owns it	Simple local value types (strings, booleans, enums)
@Binding	Parent owns it	Child view needs read/write access to parent's state
@StateObject	View creates it	View creates and owns a reference-type model
@ObservedObject	Parent passes it	View receives but does not own a reference-type model
@EnvironmentObject	Ancestor injects it	Shared model needed by many views in the hierarchy
@Environment	System provides it	System values: color scheme, locale, dismiss action
@Observable (macro)	Any	iOS 17+: replaces ObservableObject with fine-grained tracking

@Observable (iOS 17+)

@Observable
class UserModel {
    var name: String = ""
    var email: String = ""
    var avatarURL: URL?
}

struct ProfileView: View {
    @State var model = UserModel()  // Note: @State, not @StateObject

    var body: some View {
        VStack {
            Text(model.name)    // Only re-renders when name changes
            Text(model.email)   // Only re-renders when email changes
        }
    }
}

The @Observable macro tracks property access per-view, so changing email does not re-evaluate views that only read name. This is a major performance improvement over ObservableObject which notifies all subscribers on any property change.

@StateObject vs @ObservedObject

// Parent creates the model - use @StateObject
struct ParentView: View {
    @StateObject private var viewModel = ItemViewModel()
    var body: some View {
        ChildView(viewModel: viewModel)
    }
}

// Child receives the model - use @ObservedObject
struct ChildView: View {
    @ObservedObject var viewModel: ItemViewModel
    var body: some View {
        Text(viewModel.title)
    }
}

Critical rule: @StateObject persists across view re-evaluations. @ObservedObject does not - if the parent view's body re-evaluates, a new instance is created. Using @ObservedObject where @StateObject is needed causes state loss.

---

Custom Modifiers

struct CardStyle: ViewModifier {
    func body(content: Content) -> some View {
        content
            .padding()
            .background(.regularMaterial)
            .clipShape(RoundedRectangle(cornerRadius: 12))
            .shadow(radius: 2)
    }
}

extension View {
    func cardStyle() -> some View {
        modifier(CardStyle())
    }
}

// Usage
Text("Hello").cardStyle()

Conditional modifiers (avoid the naive approach)

// Bad: changes view identity, destroys state
if condition {
    text.bold()
} else {
    text
}

// Good: preserves view identity
text.bold(condition)  // For built-in modifiers that accept a boolean

// For custom conditional styling
text.opacity(condition ? 1.0 : 0.5)

---

Animations

Implicit animations

@State private var isExpanded = false

VStack {
    RoundedRectangle(cornerRadius: 12)
        .frame(height: isExpanded ? 300 : 100)
        .animation(.spring(duration: 0.4), value: isExpanded)
}

Explicit animations

withAnimation(.easeInOut(duration: 0.3)) {
    isExpanded.toggle()
}

Transitions

if showDetail {
    DetailView()
        .transition(.move(edge: .bottom).combined(with: .opacity))
}

Phase animator (iOS 17+)

PhaseAnimator([false, true]) { phase in
    Image(systemName: "heart.fill")
        .scaleEffect(phase ? 1.2 : 1.0)
        .foregroundStyle(phase ? .red : .pink)
}

---

Accessibility in SwiftUI

// Labels
Image(systemName: "heart.fill")
    .accessibilityLabel("Favorite")

// Actions
Button("Delete") { delete() }
    .accessibilityHint("Removes the item permanently")

// Grouping
HStack {
    Image(systemName: "star.fill")
    Text("4.5 out of 5 stars")
}
.accessibilityElement(children: .combine)

// Custom actions
Text(item.title)
    .accessibilityAction(named: "Delete") { delete(item) }
    .accessibilityAction(named: "Share") { share(item) }

// Traits
Text("Breaking News")
    .accessibilityAddTraits(.isHeader)

// Reduced motion
@Environment(\.accessibilityReduceMotion) var reduceMotion

withAnimation(reduceMotion ? .none : .spring()) {
    isExpanded.toggle()
}

---

Common SwiftUI pitfalls

Pitfall	Fix
View not updating	Verify correct property wrapper; @ObservedObject does not persist on re-evaluation
Sheet not dismissing	Use @Environment(\.dismiss) var dismiss then call dismiss()
List performance	Use List (built-in lazy) or LazyVStack in ScrollView for 100+ items
Dark mode broken	Use semantic colors (.primary, .secondary) and asset catalog colors
Keyboard not dismissing	Add .scrollDismissesKeyboard(.interactively) or use FocusState
Preview crashes	Provide mock data; never hit real network or Core Data in previews

UIKit Patterns

View Controller Lifecycle

Methods are called in this order:

init(coder:) or init(nibName:bundle:)
  -> loadView()
  -> viewDidLoad()           // one-time setup: add subviews, constraints
  -> viewWillAppear(_:)      // about to appear: refresh data, start animations
  -> viewIsAppearing(_:)     // iOS 13+: view has traits and geometry
  -> viewDidAppear(_:)       // fully visible: start timers, analytics
  -> viewWillDisappear(_:)   // about to leave: pause media, save draft
  -> viewDidDisappear(_:)    // fully gone: cancel network, release resources
  -> deinit                  // verify this is called (no retain cycles)

Common mistakes

• Doing layout work in viewDidLoad when geometry is not yet final - use viewDidLayoutSubviews or viewIsAppearing
• Not calling super for lifecycle methods
• Putting one-time setup in viewWillAppear (called every time the view appears)

---

Auto Layout

Programmatic constraints

class CustomViewController: UIViewController {
    private let titleLabel = UILabel()
    private let actionButton = UIButton(type: .system)

    override func viewDidLoad() {
        super.viewDidLoad()
        setupViews()
    }

    private func setupViews() {
        titleLabel.translatesAutoresizingMaskIntoConstraints = false
        actionButton.translatesAutoresizingMaskIntoConstraints = false

        view.addSubview(titleLabel)
        view.addSubview(actionButton)

        NSLayoutConstraint.activate([
            titleLabel.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 20),
            titleLabel.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
            titleLabel.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),

            actionButton.topAnchor.constraint(equalTo: titleLabel.bottomAnchor, constant: 24),
            actionButton.centerXAnchor.constraint(equalTo: view.centerXAnchor),
        ])
    }
}

Key rules

• Always set translatesAutoresizingMaskIntoConstraints = false for programmatic constraints
• Use safeAreaLayoutGuide for top/bottom to avoid notch and home indicator
• Use layoutMarginsGuide for consistent horizontal padding
• Activate constraints in batches with NSLayoutConstraint.activate([]) for performance
• Set content hugging and compression resistance priorities to resolve ambiguity

Intrinsic content size priorities

// Label should not stretch beyond its text
titleLabel.setContentHuggingPriority(.required, for: .horizontal)
// Label should not be compressed
titleLabel.setContentCompressionResistancePriority(.required, for: .horizontal)

---

UICollectionView Compositional Layout

The modern way to build complex collection views (iOS 13+).

func createLayout() -> UICollectionViewLayout {
    // Item
    let itemSize = NSCollectionLayoutSize(
        widthDimension: .fractionalWidth(0.5),
        heightDimension: .fractionalHeight(1.0)
    )
    let item = NSCollectionLayoutItem(layoutSize: itemSize)
    item.contentInsets = NSDirectionalEdgeInsets(top: 4, leading: 4, bottom: 4, trailing: 4)

    // Group
    let groupSize = NSCollectionLayoutSize(
        widthDimension: .fractionalWidth(1.0),
        heightDimension: .absolute(200)
    )
    let group = NSCollectionLayoutGroup.horizontal(layoutSize: groupSize, subitems: [item])

    // Section
    let section = NSCollectionLayoutSection(group: group)
    section.contentInsets = NSDirectionalEdgeInsets(top: 8, leading: 8, bottom: 8, trailing: 8)

    // Header
    let headerSize = NSCollectionLayoutSize(
        widthDimension: .fractionalWidth(1.0),
        heightDimension: .estimated(44)
    )
    let header = NSCollectionLayoutBoundarySupplementaryItem(
        layoutSize: headerSize,
        elementKind: UICollectionView.elementKindSectionHeader,
        alignment: .top
    )
    section.boundarySupplementaryItems = [header]

    return UICollectionViewCompositionalLayout(section: section)
}

Diffable Data Source (iOS 13+)

var dataSource: UICollectionViewDiffableDataSource<Section, Item>!

dataSource = UICollectionViewDiffableDataSource(collectionView: collectionView) {
    collectionView, indexPath, item in
    let cell = collectionView.dequeueReusableCell(
        withReuseIdentifier: "ItemCell",
        for: indexPath
    ) as! ItemCell
    cell.configure(with: item)
    return cell
}

// Apply snapshot
var snapshot = NSDiffableDataSourceSnapshot<Section, Item>()
snapshot.appendSections([.main])
snapshot.appendItems(items)
dataSource.apply(snapshot, animatingDifferences: true)

---

Coordinator Pattern

Decouple navigation logic from view controllers.

protocol Coordinator: AnyObject {
    var childCoordinators: [Coordinator] { get set }
    var navigationController: UINavigationController { get }
    func start()
}

class AppCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    let navigationController: UINavigationController

    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }

    func start() {
        let vc = HomeViewController()
        vc.coordinator = self
        navigationController.pushViewController(vc, animated: false)
    }

    func showDetail(for item: Item) {
        let detailVC = DetailViewController(item: item)
        detailVC.coordinator = self
        navigationController.pushViewController(detailVC, animated: true)
    }
}

class HomeViewController: UIViewController {
    weak var coordinator: AppCoordinator?

    func didSelectItem(_ item: Item) {
        coordinator?.showDetail(for: item)
    }
}

---

UIKit + SwiftUI Interop

Hosting SwiftUI in UIKit

let swiftUIView = MySwiftUIView(model: model)
let hostingController = UIHostingController(rootView: swiftUIView)

// As a child view controller
addChild(hostingController)
view.addSubview(hostingController.view)
hostingController.view.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    hostingController.view.topAnchor.constraint(equalTo: view.topAnchor),
    hostingController.view.leadingAnchor.constraint(equalTo: view.leadingAnchor),
    hostingController.view.trailingAnchor.constraint(equalTo: view.trailingAnchor),
    hostingController.view.bottomAnchor.constraint(equalTo: view.bottomAnchor),
])
hostingController.didMove(toParent: self)

Table view and collection view cells with SwiftUI (iOS 16+)

cell.contentConfiguration = UIHostingConfiguration {
    HStack {
        Image(systemName: item.icon)
        Text(item.title)
    }
    .padding()
}

---

Delegate and Protocol Patterns

protocol ItemSelectionDelegate: AnyObject {
    func didSelectItem(_ item: Item)
    func didDeselectItem(_ item: Item)
}

class ItemListViewController: UIViewController {
    weak var delegate: ItemSelectionDelegate?  // Always weak to prevent retain cycles

    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        let item = items[indexPath.row]
        delegate?.didSelectItem(item)
    }
}

Always declare delegates as weak var to prevent retain cycles between the delegate and the delegating object.