typed systems / app / server / package

Swift

Un percorso da ingegneria del codice: domini modellati con tipi, concorrenza controllata, networking reale, test, package e consegna. Non una pagina vetrina: una toolchain da portare in produzione.

Build plan Target Ship finale
Domain Networking Tests UI / CLI

Baseline verificata il 4 maggio 2026

La versione non è un badge: decide strumenti, vincoli e opportunità.

Linguaggio

@c, module selectors, performance controls

Toolchain

Swift 6.3.1, Swift Build in preview dentro SwiftPM

Testing

warning issues, cancellation, image attachments

Piattaforme

SDK Android ufficiale, embedded e cross-platform

Risultati attesi

Competenze come protocolli: piccole, esplicite, componibili.

01

Modellare prima di codare

Usare tipi, enum e stati espliciti per rappresentare il dominio invece di inseguire bug con controlli sparsi.

02

Scrivere Swift idiomatico

Capire quando scegliere struct, class, protocol, generic o semplice funzione, con API che leggono come intenzioni.

03

Gestire fallimenti reali

Progettare errori, optionals, JSON imperfetti, rete instabile e fallback senza trasformare tutto in if difensivi.

04

Ragionare sulla concurrency

Usare async/await, actor e isolamento Swift 6 con attenzione a cancellazione, MainActor e dati condivisi.

05

Consegnare un package

Organizzare moduli, test, documentazione DocC e dipendenze con SwiftPM, pensando già alla manutenzione.

06

Scegliere una traccia

Portare lo stesso nucleo Swift verso app native, server, CLI o librerie senza riscrivere il dominio ogni volta.

Ciclo didattico

Ogni lezione passa da problema, limite e refactor.

Swift si impara quando il compilatore diventa un collaboratore: prima si espone l'ambiguità, poi si stringe il modello finché il codice sbagliato diventa difficile da scrivere.

  1. 01Problema reale
  2. 02Tentativo ingenuo
  3. 03Limite del codice
  4. 04Concetto Swift
  5. 05Refactor
  6. 06Esercizio
  7. 07Checklist di giudizio

Build plan

Dieci moduli come milestone di un package reale.

Capire come pensa Swift prima di imparare la lista dei costrutti.

Fondamenta mentali di Swift

Swift viene presentato come linguaggio di valori, sicurezza ed espressività. Variabili, costanti e controllo di flusso entrano dentro un dominio concreto, evitando l'effetto lezione scolastica.

  1. 01 Perché Swift pensa in modo diverso
  2. 02 Value types e reference types
  3. 03 Mutabilità, immutabilità e copia
  4. 04 Optionals come modello di assenza
  5. 05 Type inference, safety ed espressività
  6. 06 Laboratorio: dominio carrello

Deliverablemodellare un piccolo dominio con ordini, utenti, prodotti e carrello

Trasformare regole reali in tipi Swift difficili da usare male.

Modellazione del dominio

Questo è il cuore del corso: struct, class, enum, protocol e generics vengono usati per rappresentare stati, regole e confini. Qui lo studente inizia davvero a scrivere Swift, non solo sintassi Swift.

  1. 01 Scegliere tra struct, class, enum e protocol
  2. 02 Associated values e stati ricchi
  3. 03 Pattern matching come linguaggio del dominio
  4. 04 Generics per riuso senza perdere significato
  5. 05 Error modeling con throws, Result ed errori custom
  6. 06 Access control e confini del modulo
  7. 07 Extensions per organizzare comportamenti
  8. 08 Laboratorio: motore di regole coupon

Deliverablecostruire un motore di regole per coupon, prenotazioni, quiz o catalogo prodotti

Insegnare gusto, giudizio e leggibilità, non solo funzionamento.

Swift idiomatico

Si lavora su codice che già funziona ma comunica male. Il modulo mostra quando usare struct o class, quando un protocollo aiuta davvero e come progettare API che si leggono come intenzioni.

  1. 01 Giudizio Swift: scegliere la forma giusta
  2. 02 Protocol-oriented programming senza dogmi
  3. 03 Composizione vs ereditarietà
  4. 04 Map, compactMap, flatMap, filter e reduce
  5. 05 Equatable, Hashable, Comparable e Codable
  6. 06 API design: nomi, firme e leggibilità
  7. 07 Laboratorio: refactor Swift idiomatico

Deliverableuna pipeline dati refactorata da codice procedurale a Swift idiomatico

Capire cosa succede sotto al codice senza anticipare complessità inutile.

Memoria, performance e semantica

Stack, heap, ARC e copy-on-write diventano strumenti pratici per diagnosticare bug e ragionare sulle scelte. Il debugging visuale conta più della teoria astratta.

  1. 01 Stack, heap e semantica pratica
  2. 02 Copy-on-write senza magia
  3. 03 ARC: ownership automatica ma non invisibile
  4. 04 Retain cycle, weak e unowned
  5. 05 Closure capture e liste di cattura
  6. 06 Performance di collection e stringhe
  7. 07 Laboratorio: diagnosticare leak e copie inutili

Deliverablediagnosticare memory leak e migliorare una piccola libreria

Capire quando il codice asincrono diventa fragile e come tenerlo isolato.

Concorrenza moderna

Swift 6.x rende la concurrency una competenza centrale. Async/await è solo l'inizio: il corso lavora su isolamento, cancellazione, MainActor, Sendable e sugli errori ricorrenti dei progetti reali.

  1. 01 Async e await: sospendere senza bloccare
  2. 02 Task e structured concurrency
  3. 03 async let per parallelismo locale
  4. 04 TaskGroup per lavoro dinamico
  5. 05 Cancellation: progettare l'interruzione
  6. 06 Actors e isolamento dello stato
  7. 07 MainActor e aggiornamenti UI
  8. 08 Sendable e data-race safety
  9. 09 Errori comuni della concurrency Swift 6
  10. 10 Laboratorio: client API concorrente

Deliverableun client API con cache, cancellazione, retry e aggiornamento UI/main thread

Separare un tutorial da un corso serio: consegnare codice gestibile.

Tooling professionale

SwiftPM, test, debugging, formattazione, documentazione e CI vengono trattati come parte del mestiere, non come appendice. Lo studente impara a preparare codice per altri sviluppatori.

  1. 01 Swift Package Manager come base professionale
  2. 02 Struttura di un package Swift
  3. 03 Dipendenze, versioni e manifest
  4. 04 Testing con Swift Testing e XCTest
  5. 05 Debugging: errori, breakpoint e strumenti
  6. 06 Linting, formattazione e coerenza
  7. 07 DocC: documentare framework e package
  8. 08 CI di base per package Swift
  9. 09 Laboratorio: libreria Swift pubblicabile

Deliverablecreare una piccola libreria Swift pubblicabile e documentabile

Rendere il corso immediatamente spendibile su dati e API vere.

Persistenza, networking e Codable nel mondo reale

Il JSON dei tutorial è troppo pulito. Qui si lavora con date, snake_case, chiavi mancanti, errori HTTP, retry, timeout, cancellazione e cache leggera.

  1. 01 JSON realistico: quando i dati non collaborano
  2. 02 Codable avanzato: chiavi, date e valori mancanti
  3. 03 DTO e dominio: separare API e modello interno
  4. 04 URLSession e richiesta HTTP robusta
  5. 05 Errori HTTP, decoding e mapping degli errori
  6. 06 Retry, timeout e cancellazione nel networking
  7. 07 Caching leggero e persistenza locale
  8. 08 Laboratorio: SDK Swift per una API reale

Deliverableun SDK Swift per consumare una API reale

Rendere il codice modificabile senza paura.

Testabilità e architettura

Si separano dominio e infrastruttura, si introducono dipendenze semplici e si testano casi asincroni ed errori. L'architettura resta concreta, senza partire per forza da iOS.

  1. 01 Dependency injection semplice, senza framework
  2. 02 Separare dominio e infrastruttura
  3. 03 Mock, fake e stub: test double con intenzione
  4. 04 Testare codice asincrono in Swift 6
  5. 05 Testare errori, edge case e contratti
  6. 06 Snapshot concettuale dell'architettura
  7. 07 Refactor di un API service fragile
  8. 08 Laboratorio: client API service testabile

Deliverablerifattorizzare un client/API service rendendolo testabile

Mostrare dove vive Swift senza ridurlo a un solo framework.

Percorsi applicativi

A questo punto il corso si divide in tracce. Il nucleo resta Swift; le destinazioni cambiano: app native, server, CLI e librerie pubblicabili.

  1. 01 Swift oltre iOS: un nucleo, più destinazioni
  2. 02 Traccia iOS/macOS: SwiftUI, stato e lifecycle
  3. 03 UIKit e AppKit quando servono davvero
  4. 04 Traccia server: Vapor, routing, database e deploy
  5. 05 Traccia CLI: ArgumentParser, file system e automazioni
  6. 06 Traccia library authoring: API, versioning e DocC
  7. 07 Condividere il dominio tra app, server, CLI e librerie
  8. 08 Laboratorio: prototipo multi-traccia

Deliverablescegliere una traccia e costruire un prototipo minimo sullo stesso nucleo di dominio

Attraversare tutto il corso con un progetto non giocattolo.

Progetto finale

Il progetto finale mette insieme dominio, rete, cache, concurrency, error handling, test, moduli, documentazione e una piccola interfaccia o CLI. Il risultato deve sembrare codice da consegnare.

  1. 01 Scegliere il progetto finale e fissare i requisiti
  2. 02 Milestone 1: dominio, use case e confini
  3. 03 Milestone 2: networking, persistenza e cache
  4. 04 Milestone 3: concurrency, resilienza ed error handling
  5. 05 Milestone 4: test suite professionale
  6. 06 Milestone 5: package, moduli e documentazione
  7. 07 Milestone 6: interfaccia SwiftUI o CLI
  8. 08 Consegna finale: review, rubric e roadmap

Deliverableclient GitHub/Hacker News, app budget, motore prenotazioni, SDK meteo/finanza, task manager offline-first o mini backend + client

Destinazioni

Lo stesso nucleo Swift cambia runtime, non identità.

SwiftUI + Foundation

Native app

interfacce, stato, aggiornamenti sul MainActor e moduli condivisi

Vapor + SwiftPM

Server

route, servizi, validazione, test e deploy leggero

ArgumentParser

CLI

tool da terminale, file system, automazioni e distribuzione

Package + DocC

Library

API pubbliche, versioning, documentazione e stabilità

Consegna finale

Ship finale: SDK Swift, test e demo.

Si costruisce un SDK Swift per una API reale: dominio separato, networking, cache, concurrency, error handling, test asincroni, documentazione DocC e una demo SwiftUI o CLI.