iOS: cos'è, architettura del sistema e linguaggio Swift

Cos'è iOS?

iOS è il sistema operativo mobile di Apple, rilasciato per la prima volta nel 2007 insieme al primo iPhone. Il sistema è costruito sul microkernel XNU, un kernel ibrido che combina componenti di Mach e FreeBSD. A differenza di Android, iOS è una piattaforma chiusa: l'installazione di app è possibile solo tramite l'App Store e il codice sorgente del sistema non è disponibile.

Apple controlla sia l'hardware che il software, garantendo un alto livello di ottimizzazione. Secondo StatCounter (2026), la quota di iOS nel mercato globale degli OS mobili è di circa il 28% e supera il 50% negli Stati Uniti e in Giappone.

Il sistema utilizza il modello App Sandbox — ogni applicazione viene eseguita in un ambiente isolato e non può accedere ai dati di altre app senza l'autorizzazione esplicita dell'utente tramite finestre di dialogo di sistema.

Storia delle versioni iOS

La prima versione, iPhone OS 1.0, non supportava app di terze parti. L'App Store è arrivato con iOS 2.0 nel 2008. Tappe fondamentali: iOS 4 (multitasking), iOS 7 (design piatto), iOS 10 (iMessage Apps), iOS 14 (widget sul desktop), iOS 17 (modalità StandBy). Ogni versione importante introduce nuove API e framework.

Architettura iOS: quattro livelli del sistema

L'architettura di iOS è composta da quattro livelli astratti, ciascuno dei quali fornisce API al livello superiore. I livelli inferiori sono il kernel e i servizi di sistema, quelli superiori sono i framework utente.

Cocoa Touch — livello superiore

Cocoa Touch è il livello di framework per la costruzione dell'interfaccia utente. Include UIKit, SwiftUI, Foundation, MapKit, NotificationCenter e altre API con cui lo sviluppatore lavora direttamente. UIKit fornisce UIViewController, UIView, UIWindow e tutti i componenti visivi.

Media — grafica e audio

Il livello Media include Core Graphics, Core Animation, Core Image, AVFoundation e Metal. Metal è un'API GPU di basso livello che offre elevate prestazioni grafiche in giochi e app di realtà aumentata. Core Animation gestisce le animazioni a livello di layer con accelerazione hardware.

Core Services — servizi di sistema

Core Services include Core Data, CloudKit, Core Location, HealthKit, Core Motion e Network. CFNetwork è un'interfaccia C di basso livello per lavorare con i protocolli di rete. Foundation è un wrapper orientato agli oggetti su Core Foundation con le classi NSString, NSArray, NSDictionary.

Core OS — kernel e sicurezza

Il livello inferiore include il kernel XNU, il filesystem APFS, i moduli crittografici (CommonCrypto, Security.framework), la gestione dell'alimentazione e i driver di periferica. A questo livello opera Secure Enclave — un coprocessore per memorizzare dati biometrici e chiavi di crittografia.

// Verifica dell'integrità di Secure Enclave tramite Security framework
#import <LocalAuthentication/LocalAuthentication.h>

LAContext *context = [[LAContext alloc] init];
NSError *error = nil;

if ([context canEvaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics
                          error:&error]) {
    NSLog(@"Secure Enclave disponibile per biometria");
} else {
    NSLog(@"Secure Enclave non disponibile: %@", error.localizedDescription);
}

Swift — il linguaggio principale per lo sviluppo iOS

Swift è un linguaggio di programmazione presentato da Apple nel 2014 come sostituto di Objective-C. È stato creato da Chris Lattner in Apple. Swift combina la sintassi dei linguaggi moderni (Rust, Kotlin, C#) con prestazioni di livello C. Secondo TIOBE (2026), Swift è tra i primi 15 linguaggi di programmazione.

Caratteristiche principali di Swift

Swift utilizza Automatic Reference Counting (ARC) per la gestione della memoria senza garbage collector. La programmazione orientata ai protocolli (POP) consente di estendere i tipi tramite estensioni di protocollo. Gli optional forniscono una gestione type-safe di nil e il pattern matching semplifica la logica di ramificazione.

import UIKit

/// Protocollo per il servizio di caricamento dati
protocol DataServiceProtocol {
    associatedtype T
    func fetch(completion: @escaping (Result<[T], Error>) -> Void)
}

/// Implementazione del servizio per caricare utenti
final class UserService: DataServiceProtocol {
    typealias T = User

    private let session: URLSession
    private let decoder: JSONDecoder

    init(session: URLSession = .shared, decoder: JSONDecoder = JSONDecoder()) {
        self.session = session
        self.decoder = decoder
    }

    func fetch(completion: @escaping (Result<[User], Error>) -> Void) {
        guard let url = URL(string: "https://api.example.com/users") else {
            completion(.failure(URLError(.badURL)))
            return
        }

        session.dataTask(with: url) { [weak self] data, response, error in
            guard let self, let data = data else {
                completion(.failure(error ?? URLError(.badServerResponse)))
                return
            }
            do {
                let users = try self.decoder.decode([User].self, from: data)
                completion(.success(users))
            } catch {
                completion(.failure(error))
            }
        }.resume()
    }
}

struct User: Codable, Identifiable {
    let id: Int
    let name: String
    let email: String
}

L'esempio mostra un'implementazione di un servizio di caricamento dati che utilizza Swift Concurrency (async/await), un protocollo con associatedtype e Codable per la decodifica JSON. ARC gestisce automaticamente la memoria e weak self previene i cicli di riferimenti forti nelle closure.

Swift Concurrency: async/await e Actors

A partire da iOS 13, Swift supporta l'asincronia incorporata tramite async/await e Actors — tipi thread-safe che proteggono lo stato dalle race condition. DispatchQueue per il multithreading viene gradualmente sostituito da async/await e strutture Task.

actor UserRepository {
    private var cache: [Int: User] = [:]
    private let service = UserService()

    func getUser(id: Int) async throws -> User {
        if let cached = cache[id] {
            return cached
        }
        let users = try await service.fetchAsync()
        guard let user = users.first(where: { $0.id == id }) else {
            throw UserError.notFound
        }
        cache[id] = user
        return user
    }
}

L'attore UserRepository garantisce che l'accesso alla cache avvenga in un unico thread, eliminando le race condition. Il compilatore verifica l'isolamento in fase di compilazione — l'accesso a una proprietà mutable di un attore è possibile solo tramite await.

Xcode e strumenti di sviluppo

Xcode è l'ambiente di sviluppo integrato (IDE) di Apple, disponibile esclusivamente su macOS. Include un editor di codice, Interface Builder per il layout visivo, simulatore di dispositivi, Instruments per il profiling e il debugger LLDB. Xcode 15 supporta Swift 5.9 con macro.

Interface Builder e Storyboard

Interface Builder consente di creare interfacce tramite drag-and-drop con generazione automatica di descrizioni XML (XIB/Storyboard). Gli Storyboard descrivono i flussi di schermate. Dal 2023, Apple raccomanda SwiftUI Preview come strumento principale per lo sviluppo visivo, sebbene Interface Builder rimanga nei progetti UIKit.

Strumenti di debug e profiling

Xcode Instruments include decine di modelli: Time Profiler (analisi CPU), Allocations (memoria), Leaks (perdite), Core Animation (FPS), Network e Energy Log. Metal Debugger consente di ispezionare le chiamate GPU e gli shader. LLDB è un debugger a console con supporto per espressioni Swift e breakpoint condizionali.

Framework principali dello sviluppo iOS

L'iOS SDK include centinaia di framework. Di seguito sono riportati i principali con cui ogni sviluppatore iOS lavora quotidianamente.

Core Data: lavoro con dati locali

Core Data è un framework per gestire il modello dati a oggetti. Consente di salvare, caricare e sincronizzare oggetti tra il thread UI e i contesti in background. iOS 17 ha introdotto SwiftData — un wrapper moderno su Core Data con supporto per Swift Macros.

UIKit vs SwiftUI: confronto degli approcci

La scelta tra UIKit e SwiftUI è una decisione architetturale chiave all'inizio dello sviluppo iOS. UIKit esiste dal 2007 e supporta tutte le versioni di iOS. SwiftUI è stato presentato nel 2019 e richiede iOS 13+.

In pratica, la maggior parte dei progetti commerciali utilizza un approccio ibrido: SwiftUI per nuovi schermi e moduli semplici, UIKit per componenti personalizzati complessi che richiedono un controllo preciso del rendering. Apple investe attivamente in SwiftUI e si prevede che diventerà il framework principale entro il 2028.

Ciclo di vita di un'app iOS

Ogni app iOS attraversa cinque stati gestiti da UIApplication e AppDelegate. In SwiftUI, il protocollo App con l'attributo @main assume questo ruolo.

Stati dell'applicazione

Not running — l'app non è stata avviata o è stata terminata dal sistema. Inactive — l'app è in primo piano ma non riceve eventi (ad esempio, durante una chiamata in arrivo). Active — stato normale, l'app riceve eventi touch. Background — l'app è minimizzata, esegue attività in background. Suspended — l'app è in memoria ma non esegue codice.

import SwiftUI

@main
struct MyApp: App {
    @Environment(\.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { oldPhase, newPhase in
            switch newPhase {
            case .active:
                print("L'app è diventata attiva")
            case .inactive:
                print("L'app è inattiva")
            case .background:
                print("L'app è andata in background")
            @unknown default:
                break
            }
        }
    }
}

Il sistema può terminare l'app in background quando la memoria è insufficiente. Lo sviluppatore deve salvare lo stato in onDisappear o tramite ScenePhase.background in modo che l'utente non perda dati durante il passaggio tra le app.

App Store: pubblicazione e requisiti

L'App Store è l'unico negozio ufficiale di app per iOS. La pubblicazione richiede un abbonamento all'Apple Developer Program ($99/anno). Ogni app viene sottoposta a moderazione — automatica (analisi statica del binario) e manuale (controllo dell'interfaccia e del contenuto).

Processo di pubblicazione

Lo sviluppatore crea un archivio in Xcode e lo carica tramite Transporter o Xcode Organizer su App Store Connect. Il tempo medio di moderazione è di 24–48 ore. App Review verifica la conformità alle linee guida: sicurezza dei dati, prestazioni, design HIG, assenza di funzionalità nascoste.

Requisiti di App Review

Particolare attenzione è dedicata alla privacy: tutti i tipi di raccolta dati devono essere dichiarati nel Privacy Manifest. Dal 2025, Apple richiede di specificare i motivi di utilizzo delle API (NSPrivacyAccessedAPITypes). Le app che utilizzano tracker senza il consenso dell'utente vengono rifiutate.