Preparazione al colloquio iOS

Domande di colloquio su iOS

20 domande frequenti di colloquio su iOS. Lo sviluppo iOS è un ambito molto richiesto incentrato su app Swift, SwiftUI e UIKit, con problemi di lifecycle, concorrenza, rete, storage, performance, test e pubblicazione su App Store. Le domande coprono livelli diversi e puoi esercitarti a rispondere a voce nel nostro simulatore di colloquio.

Inizia un colloquio AI su iOSNessuna carta di credito richiesta. 1 sessione gratuita disponibile.
Pratica per colloqui tecnici in ingleseUna modalità in cui chi non è madrelingua può esercitarsi a superare i colloqui tecnici.

Domande per principianti

1Che cos’è @Binding in SwiftUI e in cosa differisce da @State?

Se il padre possiede un booleano in @State, passando setting il figlio riceve un valore. Il padre può aggiornarlo ma modificare una copia locale non riscrive lo stato originale. Con $setting e @Binding il figlio legge e scrive lo stesso spazio: un Toggle modifica l’unica fonte di verità. Il binding non possiede né persiste il dato e la vita resta quella dello stato del padre. Per applicare solo al salvataggio creo una bozza e alla conferma invio un’azione o assegno tramite binding, definendo che cosa accade all’annullamento.

struct ParentView: View {
    @State private var isOn: Bool = false
    
    var body: some View {
        VStack {
            Text("Switch is: \(isOn ? "ON" : "OFF")")
            // Pass binding using $ prefix
            CustomToggle(isOn: $isOn)
        }
    }
}

struct CustomToggle: View {
    @Binding var isOn: Bool
    
    var body: some View {
        Button("Toggle") {
            isOn.toggle() // Modifies parent's @State
        }
    }
}
Prova a rispondere a questa domanda con un coach IA

2Qual è il ruolo di un provisioning profile nel rilascio di un'applicazione iOS?

Nel rilascio su iOS, un provisioning profile funge da pacchetto firmato crittograficamente che raccorda i requisiti di sicurezza di Apple con il binario dell'app e i dispositivi di destinazione. Il suo ruolo principale è indicare al sistema operativo iOS e ad App Store Connect che l'applicazione è autorizzata a essere eseguita secondo specifiche regole di distribuzione. Un provisioning profile raggruppa diversi elementi critici: l'App ID (Bundle Identifier), i certificati di firma autorizzati che confermano chi ha compilato l'app, gli entitlement e le funzionalità (capabilities) concesse all'app (come le notifiche push, Sign in with Apple o iCloud) e — nei profili non destinati ad App Store come Development o Ad-Hoc — un elenco di UDID (Unique Device Identifier) dei dispositivi consentiti. Per i profili di rilascio di App Store, gli UDID dei singoli dispositivi vengono omessi perché Apple consente la distribuzione a qualsiasi dispositivo consumer tramite l'App Store.

Provisioning Profile (.mobileprovision)
├── App ID / Bundle Identifier (e.g., com.example.app)
├── Certificates (Public key / Distribution Certificate)
├── Entitlements (e.g., Push Notifications, Associated Domains)
└── Device UDIDs (Present for Development/Ad-Hoc; omitted for App Store distribution)
Prova a rispondere a questa domanda con un coach IA

3Cosa significa per un'app iOS eseguire operazioni in background e quali limiti fondamentali impone il sistema a tali operazioni?

Eseguire operazioni in background su iOS significa eseguire codice quando l'app non è attualmente attiva sullo schermo o visibile all'utente. Quando un utente esce da un'app, questa passa dallo stato attivo in primo piano (foreground) al background e, poco dopo, a uno stato di sospensione in cui l'esecuzione viene messa in pausa, sebbene la sua memoria rimanga nella RAM. Per preservare l'autonomia della batteria, la reattività del sistema e le risorse del dispositivo, iOS controlla rigorosamente l'esecuzione in background. Il sistema limita il tempo in cui un'app può eseguire codice una volta passata in background (in genere una breve finestra temporale finita di circa 30 secondi, a meno che non si utilizzino modalità di background specifiche o attività pianificate), riduce la priorità di CPU e rete e può terminare le app sospese se il dispositivo riscontra una pressione sulla memoria.

import UIKit

NotificationCenter.default.addObserver(
    forName: UIApplication.didEnterBackgroundNotification,
    object: nil,
    queue: .main
) { _ in
    print("App entered background. Code execution will pause soon unless extended.")
}
Prova a rispondere a questa domanda con un coach IA

4Che cos'è un publisher in Combine e in cosa differisce da un subscriber in un tipico flusso di dati iOS?

In Combine, un Publisher emette un flusso di valori nel tempo e può terminare con un evento di completamento (completando con successo o fallendo con un errore). Dichiara due tipi associati: `Output` (il tipo di dato che produce) e `Failure` (il tipo di errore che può emettere). Un Subscriber riceve valori ed eventi del ciclo di vita da un publisher. In un tipico flusso di dati iOS, i publisher fungono da sorgente o produttore di eventi asincroni (come risposte di rete, notifiche o input dell'utente), mentre i subscriber fungono da consumer che reagiscono ai valori emessi, gestiscono gli errori e rispondono al completamento (come l'aggiornamento dello stato della UI o la scrittura in un database). Il subscriber si collega a un publisher, riceve un token di sottoscrizione e richiede la domanda (demand) di elementi.

import Combine

// Publisher: emits a sequence of integers
let numberPublisher = [1, 2, 3].publisher

// Subscriber: consumes the emitted integers
let cancellable = numberPublisher.sink(
    receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Finished")
        case .failure(let error):
            print("Error: \(error)")
        }
    },
    receiveValue: { value in
        print("Received: \(value)")
    }
)
Prova a rispondere a questa domanda con un coach IA

5Cosa significa async/await in Swift e come lo utilizzeresti per chiamare una API (Application Programming Interface) asincrona da un'app iOS?

`async/await` è la sintassi integrata di Swift per scrivere codice asincrono in modo lineare, leggibile e sequenziale, anziché utilizzare closure annidate e completion handler. Contrassegnare una funzione con `async` indica al compilatore che la funzione può sospendere la propria esecuzione in attesa del completamento di un'operazione prolungata (come richieste di rete o operazioni di I/O su file). La parola chiave `await` indica un punto di sospensione: l'esecuzione della funzione corrente si interrompe temporaneamente, liberando il thread sottostante per svolgere altro lavoro, e riprende non appena il risultato atteso o l'eventuale errore è pronto. Per chiamare un'API asincrona in un'app iOS, si invoca il metodo `async` preceduto da `await` (e da `try await` se la funzione può generare errori/eccezioni) all'interno di un contesto asincrono, come un'altra funzione `async` o un blocco `Task`.

func fetchUserData(from url: URL) async throws -> User {
    let (data, response) = try await URLSession.shared.data(from: url)
    
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }
    
    return try JSONDecoder().decode(User.self, from: data)
}
Prova a rispondere a questa domanda con un coach IA

6Quando è opportuno utilizzare UserDefaults in un'app iOS e quali tipi di dati non dovrebbero esservi memorizzati?

UserDefaults è progettato per memorizzare preferenze utente, impostazioni e flag di piccole dimensioni e leggeri tra i lanci dell'app (ad esempio, preferenze di tema, livello del volume o un flag booleano `hasSeenOnboarding`). Supporta i tipi di property list come String, Int, Double, Bool, Date, Data, Array e Dictionary. NON si dovrebbero memorizzare: 1. Informazioni sensibili (come password utente, chiavi private o token di autenticazione), poiché UserDefaults salva i dati non cifrati in un file plist in testo non codificato. 2. Dataset di grandi dimensioni, documenti o file multimediali (come immagini, audio o payload JSON corposi), poiché l'intero file plist viene caricato in memoria all'accesso, causando un elevato consumo di memoria e rallentando l'avvio dell'applicazione.

// Saving simple preference values
UserDefaults.standard.set(true, forKey: "hasCompletedOnboarding")
UserDefaults.standard.set("dark", forKey: "preferredTheme")

// Reading values back
let hasCompletedOnboarding = UserDefaults.standard.bool(forKey: "hasCompletedOnboarding")
let theme = UserDefaults.standard.string(forKey: "preferredTheme") ?? "system"
Prova a rispondere a questa domanda con un coach IA

7Che cos'è ARC (Automatic Reference Counting) in Swift e come gestisce il ciclo di vita delle istanze di classe in un'app iOS?

ARC (Automatic Reference Counting) è il meccanismo di gestione della memoria a tempo di compilazione di Swift per tracciare e gestire il ciclo di vita delle istanze di classe (tipi per riferimento). Ogni volta che viene creata una nuova istanza di una classe e assegnata a un riferimento forte (strong reference), ARC tiene traccia di un conteggio interno dei riferimenti per quell'istanza. Finché esiste almeno un riferimento forte verso un'istanza, ARC la mantiene in memoria. Quando tutti i riferimenti forti vengono rimossi e il conteggio dei riferimenti scende a zero, ARC dealloca immediatamente l'istanza per liberare memoria, invocando automaticamente il metodo `deinit` dell'istanza subito prima della deallocazione. A differenza della garbage collection a runtime in ambienti come Java o .NET, ARC non esegue cicli periodici di pulizia (sweep); il compilatore Swift inserisce le opportune chiamate di retain e release direttamente nel binario durante la compilazione.

class User {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) initialized")
    }
    deinit {
        print("\(name) deallocated")
    }
}

var ref1: User? = User(name: "Alice") // count = 1
var ref2: User? = ref1               // count = 2

ref1 = nil                           // count = 1
ref2 = nil                           // count = 0 -> deinit called
Prova a rispondere a questa domanda con un coach IA

8Come si esegue una semplice richiesta HTTP (Hypertext Transfer Protocol) GET con URLSession in un'app iOS?

Per eseguire una semplice richiesta HTTP GET in un'app iOS, si crea un oggetto URL e lo si passa a un'istanza di URLSession, come URLSession.shared. È possibile eseguire la richiesta utilizzando una completion handler di data task (URLSession.shared.dataTask(with: url) { data, response, error in ... }) oppure tramite la moderna concorrenza di Swift (let (data, response) = try await URLSession.shared.data(from: url)). Quando si usa l'approccio tradizionale basato su data task, è necessario chiamare .resume() sul task per avviarlo, gestire eventuali errori di trasporto, ispezionare il codice di stato HTTPURLResponse e assicurarsi che tutti gli aggiornamenti della UI siano inviati al thread principale.

guard let url = URL(string: "https://api.example.com/items") else { return }

let task = URLSession.shared.dataTask(with: url) { data, response, error in
    if let error = error {
        print("Network error: \(error.localizedDescription)")
        return
    }
    
    guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
        print("Server error or invalid status code")
        return
    }
    
    if let data = data {
        DispatchQueue.main.async {
            // Update UI on main thread
        }
    }
}
task.resume()
Prova a rispondere a questa domanda con un coach IA

9Che cos'è Instruments in Xcode e come lo utilizzeresti per analizzare un semplice problema di prestazioni in un'app iOS?

Instruments è lo strumento di analisi e profilazione delle prestazioni di Apple integrato in Xcode. Consente agli sviluppatori di monitorare il comportamento a runtime, l'utilizzo della CPU, le allocazioni di memoria, i memory leak e le prestazioni di rendering della UI. Per esaminare un semplice problema di prestazioni (come scatti dell'interfaccia o un elevato utilizzo della CPU), si avvia Instruments da Xcode (tramite Product -> Profile), si sceglie un template appropriato (come Time Profiler per colli di bottiglia della CPU o Allocations/Leaks per problemi di memoria) e si registra una traccia riproducendo il flusso utente problematico su un dispositivo. Dopo la registrazione, si analizzano il call tree e le stack trace più pesanti per individuare con precisione i metodi che causano rallentamenti o un consumo eccessivo di risorse, consentendo di misurare e localizzare il collo di bottiglia prima di modificare il codice.

1. In Xcode, select Product -> Profile (Builds with Release optimizations).
2. Select the 'Time Profiler' template.
3. Click Record and perform the sluggish action in the app.
4. Stop recording.
5. Inspect the Call Tree tab:
   - Enable 'Separate by Thread' and 'Hide System Libraries'.
   - Trace the heaviest call stack on the Main Thread to identify the blocking function.
Prova a rispondere a questa domanda con un coach IA

10Che cos'è APNs (Apple Push Notification service) e quale ruolo svolge nel recapito delle notifiche push a un'app iOS?

APNs (Apple Push Notification service) è il servizio intermediario basato su cloud di Apple che instrada in modo sicuro le notifiche push dai server di backend (server provider) ai dispositivi Apple. Poiché i dispositivi mobili non possono mantenere connessioni socket aperte e continue con il backend di ogni singola app senza scaricare la batteria e consumare troppa larghezza di banda di rete, Apple mantiene un'unica connessione persistente a basso consumo energetico tra ciascun dispositivo e APNs. Quando l'app si registra per le notifiche remote, APNs genera un device token univoco e opaco che identifica quella specifica installazione dell'app su quello specifico dispositivo. L'app invia questo token al server provider di backend. Quando il provider desidera notificare l'utente, costruisce un payload e lo invia insieme al device token ad APNs tramite HTTP/2. APNs individua quindi la connessione attiva per quel dispositivo e recapita il payload della notifica push direttamente a iOS, che mostra l'avviso o attiva l'app in base alla configurazione.

[Provider Server] ---> (HTTP/2 Request + Device Token + Payload) ---> [APNs]
                                                                           |
                                                               (Persistent APNs Connection)
                                                                           v
                                                                    [iOS Device / App]
Prova a rispondere a questa domanda con un coach IA

Domande intermedie

11Come integreresti le notizie appena scaricate in un feed UITableView affinché appaiano per prime e ogni ID compaia una sola volta?

Costruisco la lista nell’ordine delle notizie ricevute, registrando gli ID già inseriti, poi aggiungo le vecchie voci con ID ancora assenti. Applico la modifica sul MainActor e interrompo l’indicatore di aggiornamento sia in caso di successo sia in caso di errore.

Prova a rispondere a questa domanda con un coach IA

12Che cosa distingue un actor Swift da un tipo riferimento ordinario quando più task usano dati mutabili?

Condividere una classe non protegge automaticamente le proprietà mutabili. Un actor isola il proprio stato e l’executor coordina gli accessi isolati. Attraversare il confine richiede in genere un’operazione asincrona, riducendo le corse senza bloccare manualmente ogni proprietà. Non ha un thread dedicato e non rende atomico un intero metodo async. Durante await altro lavoro può cambiare lo stato. Ricontrollo le ipotesi alla ripresa, raggruppo gli aggiornamenti degli invarianti in sezioni sincrone e uso versioni o transizioni attraverso le sospensioni. Membri nonisolated e valori trasferiti hanno vincoli propri. L’ordine applicativo resta da progettare.

Prova a rispondere a questa domanda con un coach IA

13Come testeresti caricamento, successo e annullamento di un view model iOS senza invocare la vera API?

Inietto una finta API conforme a un piccolo protocollo e ne controllo il risultato async. Avvio il caricamento, controllo lo stato, completo con dati o errore e verifico esito e dati conservati. Nell’annullamento controllo che il task venga cancellato, il caricamento si chiuda come previsto e non appaia un errore ordinario salvo scelta esplicita. Un completamento tardivo prova che una richiesta superata non sovrascriva una nuova selezione. Rispetto l’isolamento dell’actor e uso sincronizzazione esplicita o un orologio controllabile invece di pause arbitrarie. Copro carichi ripetuti, rilascio e uscita dallo schermo. Verifico comportamenti osservabili senza rete o credenziali.

Prova a rispondere a questa domanda con un coach IA

14Come realizzeresti una pipeline Combine per un campo di testo di ricerca che esegua il debounce dell'input, ignori i duplicati, effettui una richiesta di rete e aggiorni l'UI (User Interface) in modo sicuro?

Per creare una pipeline di ricerca sicura in Combine: 1. **Debounce e deduplicazione:** Prendi il publisher della query di ricerca (ad es. `$queryText`), applica `.debounce(for: .milliseconds(300), scheduler: RunLoop.main)` per attendere le pause nella digitazione e `.removeDuplicates()` per ignorare le stringhe di ricerca invariate. 2. **Richiesta di rete e cancellazione:** Mappa ogni query su un publisher di richiesta di rete e appiattisci il flusso usando `.switchToLatest()`. In questo modo si annullano automaticamente le richieste in corso quando arriva una nuova query di ricerca, evitando race condition e risultati obsoleti. 3. **Isolamento degli errori:** Intercetta gli errori di rete all'interno del publisher interno (ad es. `.catch { _ in Just([]) }`), così che eventuali fallimenti di rete non terminino lo stream principale del testo di ricerca. 4. **Distribuzione sul thread principale:** Applica `.receive(on: DispatchQueue.main)` prima di aggiornare lo stato o assegnare i valori alle proprietà dell'interfaccia utente.

import Combine
import Foundation

class SearchViewModel: ObservableObject {
    @Published var query: String = ""
    @Published var searchResults: [String] = []
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        $query
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .removeDuplicates()
            .map { query -> AnyPublisher<[String], Never> in
                guard !query.trimmingCharacters(in: .whitespaces).isEmpty else {
                    return Just([]).eraseToAnyPublisher()
                }
                return self.performSearch(query)
                    .catch { _ in Just([]) }
                    .eraseToAnyPublisher()
            }
            .switchToLatest()
            .receive(on: DispatchQueue.main)
            .assign(to: &$searchResults)
    }
    
    private func performSearch(_ term: String) -> AnyPublisher<[String], Error> {
        let url = URL(string: "https://api.example.com/search?q=\(term)")!
        return URLSession.shared.dataTaskPublisher(for: url)
            .map(\.data)
            .decode(type: [String].self, decoder: JSONDecoder())
            .eraseToAnyPublisher()
    }
}
Prova a rispondere a questa domanda con un coach IA

15Come utilizzeresti async/await e la cancellazione dei Task in Swift per implementare una schermata che carica dati dalla rete evitando di aggiornare la UI (User Interface) dopo che l'utente si è allontanato dalla vista?

Definirei il caricamento di rete come una funzione `async` su un servizio o un view model e la eseguirei da un `Task` il cui ciclo di vita sia associato a quello della schermata. In UIKit, ciò comporta in genere la memorizzazione di un riferimento come `var loadTask: Task<Void, Never>?` nel view controller o nel view model, avviandolo quando la schermata deve caricare i dati e cancellandolo in `viewWillDisappear`, `deinit` o prima di avviare una nuova richiesta a seconda del ciclo di vita desiderato. In SwiftUI, preferirei usare il modificatore `.task` o `.task(id:)` quando possibile, poiché SwiftUI ne gestisce automaticamente l'annullamento quando la vista scompare o l'identificatore cambia. All'interno del task, richiamerei l'API di rete asincrona con `try await`, gestirei l'annullamento separatamente dai veri errori e verificherei lo stato di cancellazione prima di applicare i risultati in caso di molteplici `await` o passaggi di elaborazione. Le modifiche allo stato della UI devono avvenire sul main actor, rendendo il view model `@MainActor` o utilizzando `await MainActor.run`. Per evitare aggiornamenti di UI obsoleti, cancellerei i task precedenti, eviterei task detached o globali per operazioni legate alla schermata e, facoltativamente, confronterei l'identificatore della richiesta o l'ID dell'elemento corrente prima di applicare il risultato.

@MainActor
final class UsersViewController: UIViewController {
    private var loadTask: Task<Void, Never>?
    private let service: UserService

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

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        loadTask?.cancel()
    }

    private func loadUsers() {
        loadTask?.cancel()
        loadingView.isHidden = false

        loadTask = Task { [weak self] in
            do {
                let users = try await self?.service.fetchUsers() ?? []
                try Task.checkCancellation()

                guard let self else { return }
                self.loadingView.isHidden = true
                self.tableModel = users
                self.tableView.reloadData()
            } catch is CancellationError {
                // User navigated away or a new load replaced this one; do not update UI.
            } catch {
                guard let self else { return }
                self.loadingView.isHidden = true
                self.showError(error)
            }
        }
    }
}
Prova a rispondere a questa domanda con un coach IA

16Come sceglieresti tra UserDefaults, Keychain, file system, SQLite e Core Data in base alle diverse tipologie di dati dell'app?

La scelta del meccanismo di archiviazione appropriato su iOS dipende dalla sensibilità dei dati, dalle dimensioni, dalla complessità relazionale, dai requisiti di query e dal ciclo di vita dei backup: 1. **Keychain**: Per dati sensibili (token di autenticazione, password, chiavi di cifratura, credenziali biometriche). Offre cifratura basata su hardware, persiste dopo la reinstallazione dell'app e rimane sicuro anche in ambienti sandbox compromessi. 2. **UserDefaults**: Per preferenze e flag leggeri e non sensibili (ad esempio `hasCompletedOnboarding`, tema selezionato). Poiché viene caricato interamente in memoria come property list, non deve essere utilizzato per dataset di grandi dimensioni, contenuti multimediali o token sensibili. 3. **File system (Documents / Caches / Application Support)**: Per file distinti e file binari di grandi dimensioni (immagini scaricate, audio, PDF). `Documents` è accessibile all'utente ed è incluso nei backup di iCloud; `Caches` è destinato a contenuti eliminabili e riscaricabili; `Application Support` serve per file persistenti non visibili all'utente. 4. **SQLite**: Per dati strutturati e tabulari che richiedono query indicizzate veloci, operazioni di massa o condivisione del database multipiattaforma senza l'overhead di un grafo a oggetti. 5. **Core Data / SwiftData**: Per grafi di oggetti complessi con relazioni, tracciamento delle modifiche, caricamento su richiesta (faulting), gestione dell'annullamento (undo management) e integrazione diretta con UIKit (`NSFetchedResultsController`) o SwiftUI (`@Query`).

- Auth tokens / API keys          -> Keychain (Hardware-backed encrypted store)
- App settings / UI flags         -> UserDefaults (Lightweight key-value, non-sensitive)
- Downloaded videos / PDFs        -> File System (Documents / Caches directory)
- 50k items with complex queries   -> SQLite / Core Data / SwiftData (Indexed, relationship-aware)
Prova a rispondere a questa domanda con un coach IA

17In una schermata UIKit di produzione con callback provenienti da un view model, come decideresti se catturare self come weak, unowned o strong nei gestori delle closure?

Nell'architettura UIKit in cui un view controller interagisce con un view model tramite callback, la strategia di cattura è determinata dal concetto di ownership e dal ciclo di vita: 1. `[weak self]`: L'approccio standard e più sicuro per closure memorizzate o escaping (come le callback di eventi del view model o gli handler di completamento asincrono di rete/dati). Poiché il view controller possiede il view model, catturare `self` in modo forte (strong) in una callback salvata dal view model crea un ciclo di riferimenti forti (`VC -> VM -> closure -> VC`). `[weak self]` converte `self` in un opzionale (`UIViewController?`), consentendone la corretta deallocazione ed evitando memory leak. 2. `[unowned self]`: Assume che `self` non sarà mai nil nel momento in cui la closure viene eseguita. Va utilizzato con estrema cautela nelle schermate UI. Se un'attività asincrona o una callback si completa dopo che il view controller è stato rimosso e deallocato, accedere a `unowned self` genera un crash irreversibile a runtime. Per questa ragione, `[weak self]` è generalmente preferito a `unowned` nelle callback di UI in UIKit di produzione. 3. **Cattura forte (Strong capture, predefinita, senza capture list):** Adeguata quando la closure è non-escaping (ad esempio operazioni standard su collezioni come `map`/`filter`) oppure quando la closure ha un ciclo di vita breve e non crea un ciclo di ownership verso `self`.

final class ProfileViewController: UIViewController {
    private let viewModel: ProfileViewModel

    init(viewModel: ProfileViewModel) {
        self.viewModel = viewModel
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder: NSCoder) { fatalError() }

    override func viewDidLoad() {
        super.viewDidLoad()
        
        // VM stores the callback -> capture weak self to break retain cycle
        viewModel.onDataUpdated = { [weak self] state in
            guard let self else { return }
            self.updateUI(with: state)
        }
    }

    private func updateUI(with state: ProfileState) { /* Update views */ }
}
Prova a rispondere a questa domanda con un coach IA

Domande per esperti

18Come introdurresti SwiftUI in una grande applicazione UIKit una schermata alla volta?

Scelgo una schermata circoscritta con ingressi e uscite chiari e la ospito in UIHostingController mantenendo navigazione e ciclo di vita UIKit. Mantengo logica e repository indipendenti dai framework e un solo proprietario per stato. Per riutilizzare controlli o controller UIKit impiego UIViewRepresentable o UIViewControllerRepresentable e, se serve, un coordinatore per i callback. Verifico navigazione, chiusura, focus, accessibilità, temi e versioni disponibili. Testo comportamento e transizioni, confronto prestazioni e aspetto e adotto un ingresso reversibile se il rischio lo richiede. Ripeto per schermata senza duplicare lo stato.

Prova a rispondere a questa domanda con un coach IA

19Devi rilasciare un'applicazione iOS ad alto traffico con una migrazione del database e una modifica alle API (Application Programming Interface) di backend; come progetteresti il piano di rollout per ridurre al minimo l'impatto sugli utenti?

Progettare un piano di rollout per un'app iOS ad alto traffico con migrazioni del database e modifiche alle API di backend richiede il disaccoppiamento tra il deployment e l'attivazione delle funzionalità, visti i vincoli del client iOS (aggiornamenti asincroni da parte degli utenti e impossibilità di forzare rollback dei binari lato client). 1. Compatibilità del backend: implementare una strategia expand-and-contract. Distribuire le API v2 parallelamente alle API v1, in modo che sia le versioni legacy sia quelle aggiornate del client funzionino contemporaneamente senza modifiche che causino rotture (breaking changes). 2. Migrazione resiliente del database: garantire che le migrazioni dello schema locale (ad es. SQLite, Core Data, SwiftData) siano idempotenti, non distruttive e gestiscano in sicurezza i salti di più versioni (ad es. aggiornamento da N-3 a N) senza bloccare il thread principale né innescare cicli di crash all'avvio. 3. Rilascio controllato e dinamico (Dynamic Gating): rilasciare le nuove funzionalità client in modalità "dark" protette da feature flag o configurazioni remote gestite dal server. Mantenere il feature flag disabilitato durante la distribuzione iniziale. 4. Rollout graduale e monitoraggio: distribuire l'app tramite il Phased Release di App Store (un rollout progressivo in 7 giorni). Monitorare costantemente la telemetria, il tasso di crash, le metriche di successo delle migrazioni del database e i tassi di errore delle API. In presenza di anomalie, sospendere il rilascio graduale in App Store Connect e disattivare i feature flag senza dover ricorrere a un rollback di emergenza del binario.

Phase 1 (Backend Expand): Deploy API v2 supporting both new and legacy payloads.
Phase 2 (Client Distribution & Migration): Release client v2.0 via App Store Phased Release (1% -> 100%). DB migrates safely on first launch. Feature flag remains OFF.
Phase 3 (Validation & Feature Enablement): Monitor crash rates & migration success. Incrementally ramp Remote Config flag (10% -> 50% -> 100%).
Phase 4 (Backend Contract): Once legacy app adoption drops below deprecation threshold, sunset API v1.
Prova a rispondere a questa domanda con un coach IA

20Stai progettando la sincronizzazione offline-first per un'app di note in cui le modifiche devono convergere tra dispositivi diversi, ma iOS potrebbe posticipare o interrompere i task in background. Quale architettura di esecuzione in background sceglieresti?

Un'architettura di sincronizzazione offline-first considera il database locale (come SQLite, Core Data o SwiftData) come l'unica fonte di verità immediata per lo stato della UI, mentre le mutazioni vengono accodate in una coda outbox persistente su disco, in modo che le modifiche non inviate sopravvivano alla terminazione del processo. Per gestire l'esecuzione in background opportunistica e non deterministica di iOS, il lavoro in background viene articolato su più livelli: 1. Svuotamento dell'outbox al passaggio in background: avviato tramite `UIApplication.shared.beginBackgroundTask(expirationHandler:)` per completare mutazioni in corso o rapide. 2. Sincronizzazione periodica programmata: registrata con `BGTaskScheduler` tramite `BGAppRefreshTask` per sincronizzazioni leggere di metadati/delta e `BGProcessingTask` per operazioni di sincronizzazione più pesanti. 3. Sincronizzazione di asset di grandi dimensioni: gestita fuori processo tramite una `URLSessionConfiguration` in background usando upload e download di file. 4. Sincronizzazione attivata dal server: risvegli opportunistici tramite notifiche push silenziose (`content-available: 1`). Poiché i task in background possono essere interrotti o rischedulati in qualsiasi momento, le operazioni devono utilizzare chiavi di idempotenza generate dal client (ad es. UUID) per consentire retry sicuri senza duplicare dati. Se viene richiamato l'handler `expirationHandler` di un task, il lavoro in corso deve essere annullato immediatamente, le operazioni non confermate devono essere reimpostate su stato in sospeso e deve essere chiamato `setTaskCompleted(success: false)`. La consistenza eventuale viene garantita tramite meccanismi di risoluzione dei conflitti quali CRDT (Conflict-free Replicated Data Types), vettori di versione o last-write-wins con tombstone di cancellazione, assicurando che i delta remoti non sovrascrivano mutazioni locali dell'outbox non ancora confermate.

import BackgroundTasks
import Foundation

final class NoteSyncCoordinator {
    static let shared = NoteSyncCoordinator()
    private let syncTaskID = "com.notesapp.sync.refresh"

    func registerSyncTask() {
        BGTaskScheduler.shared.register(forTaskWithIdentifier: syncTaskID, using: nil) { task in
            guard let refreshTask = task as? BGAppRefreshTask else { return }
            self.handleAppRefresh(task: refreshTask)
        }
    }

    func scheduleNextSync() {
        let request = BGAppRefreshTaskRequest(identifier: syncTaskID)
        request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
        try? BGTaskScheduler.shared.submit(request)
    }

    private func handleAppRefresh(task: BGAppRefreshTask) {
        scheduleNextSync()
        let syncTask = Task {
            do {
                try await SyncEngine.shared.flushPersistentOutboxAndFetchDeltas()
                task.setTaskCompleted(success: true)
            } catch {
                task.setTaskCompleted(success: false)
            }
        }

        task.expirationHandler = {
            syncTask.cancel()
        }
    }
}
Prova a rispondere a questa domanda con un coach IA

Preparati ai colloqui sul telefono: Sviluppatore iOS

Rispondi ad alta voce e ricevi feedback dall’IA nell’app per Android.

Scarica EngineerSpeak su Google Play
Scansiona per scaricare