Inizia la prova gratuita
Tendenze Novità Generi Autori
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Ricerca in corso...
SoBrief
Clean Architecture

Clean Architecture

Costruisci software che resti economico da modificare, senza pagare per una complessità di cui potresti non avere mai bisogno.
di Robert C. Martin 2017 432 pagine
4.21
7.000+ valutazioni
Ascolta
Immersivi
V2.3
Amazon Kindle Audible
Prova l'accesso completo per 3 giorni
Sblocca l'ascolto e molto altro!
Continua

Punti chiave

Valuta l’architettura in base a quanto resta accessibile la prossima modifica ordinaria

La progettazione è una scelta economica. Martin considera progettazione e architettura come un continuum di decisioni, dalla struttura generale ai piccoli dettagli di implementazione. Il loro scopo è contenere lo sforzo umano necessario per costruire e mantenere un sistema durante tutto il suo ciclo di vita. In un caso aziendale, il personale di sviluppo e il monte salari crebbero rapidamente, mentre la produzione di codice rimase quasi invariata. All’ottava versione, produrre ogni riga di codice costava circa 40 volte più che nella prima. Il disordine accumulato aveva trasformato il lavoro sulle funzionalità nel lavoro di orientarsi nel codice preesistente.

Un lavoro pulito può essere più veloce. In un piccolo esercizio di sei giorni per convertire numeri in numeri romani, i giorni in cui si usava lo sviluppo guidato dai test richiesero circa il 10 per cento di tempo in meno rispetto ai giorni senza tale disciplina. È un esempio, non uno studio definitivo, ma mette in discussione l’idea che ripulire il codice sia un lusso da rimandare.

Analisi

La prospettiva economica rende l’architettura comprensibile anche a chi non scrive codice: l’aumento dei costi di modifica è un rischio aziendale, non una preferenza degli sviluppatori. Chiarisce anche perché un sistema possa funzionare correttamente e tuttavia essere in cattive condizioni. Le prove, però, vanno valutate con cautela. Le righe di codice sono una misura approssimativa del valore prodotto e un esercizio di sei giorni non può dimostrare un vantaggio universale in termini di produttività per una singola pratica. La verifica più solida consiste nel chiedersi se i team riescano a realizzare modifiche probabili con uno sforzo prevedibile e senza destabilizzare ripetutamente comportamenti estranei.

Proteggi la modificabilità con la stessa cura riservata alle funzionalità che già funzionano

Il software ha due valori. Il suo comportamento produce o fa risparmiare valore oggi; la sua struttura determina quanto facilmente quel comportamento possa essere modificato. È facile trascurare il secondo valore, perché le richieste di nuove funzionalità arrivano con urgenza, mentre i danni architetturali si accumulano in silenzio. Martin riprende la distinzione tra importanza e urgenza associata a Eisenhower: un lavoro urgente non è automaticamente importante. Gli sviluppatori devono aiutare chi prende le decisioni a vedere il costo futuro di relegare l’architettura in secondo piano.

L’entità della richiesta non è l’unico fattore di costo. Una richiesta piccola può essere costosa se è in contrasto con la struttura del sistema. Se un nuovo report richiede modifiche in moduli non correlati, l’architettura rende il cambiamento più difficile di quanto giustifichi la richiesta stessa. Preservare la modificabilità non significa predisporre ogni opzione immaginabile. Significa evitare che le modifiche comuni e prevedibili diventino interventi chirurgici sull’intero sistema.

Analisi

Questa distinzione ricorda quella tra prestazioni operative e resilienza organizzativa: un sistema può raggiungere l’obiettivo di oggi e perdere al tempo stesso la capacità di reagire domani. La trappola dell’urgenza è particolarmente potente nelle organizzazioni di prodotto, dove i lanci visibili vengono premiati e i costi di manutenzione evitati no. La flessibilità, tuttavia, non è gratuita. Ogni confine e astrazione richiede attenzione, quindi l’architettura dovrebbe proteggere percorsi di cambiamento plausibili, non ipotetici. La conversazione pratica non riguarda tanto la scelta tra funzionalità e architettura, quanto il rendere visibile il costo di rimandare il lavoro strutturale.

Limita il flusso di controllo, l’indirezione e le mutazioni per rendere i programmi più facili da testare

La programmazione progredisce attraverso i vincoli. Martin presenta la programmazione strutturata come disciplina che limita i salti senza restrizioni, la programmazione orientata agli oggetti come controllo più sicuro delle chiamate indirette e la programmazione funzionale come disciplina che limita la modifica dello stato. Ciascuna rende più difficile scrivere certi tipi di codice, in cambio di codice più facile da comprendere. Il lavoro di Dijkstra sulla programmazione strutturata mostrò come sequenza, scelta e ripetizione consentano di suddividere i programmi in unità più piccole, che si possono esaminare e testare.

Lo stato ha un costo in termini di concorrenza. L’immutabilità significa che i valori non vengono sovrascritti alla leggera; ciò riduce le race condition e gli aggiornamenti in conflitto, anche se non elimina tutti i problemi di concorrenza. L’Event sourcing ne è un esempio: si memorizzano le transazioni, come depositi e prelievi, e da queste si ricava il saldo di un conto invece di sostituirlo ripetutamente. Le istantanee possono ridurre la quantità di cronologia da ricalcolare.

Analisi

L’idea unificante non è che i programmatori debbano adottare un unico paradigma di moda, ma che i vincoli possano rendere il ragionamento componibile. Questo richiama l’ingegneria della sicurezza, in cui limitare le operazioni pericolose spesso conta più che chiedere alle persone di essere vigili. L’affermazione sulla concorrenza va circoscritta: i dati immutabili riducono lo stato mutabile condiviso, ma i sistemi devono comunque affrontare problemi di ordinamento, contesa per le risorse e coerenza distribuita. Anche le cronologie degli eventi comportano costi di archiviazione, rielaborazione e interpretazione. La domanda utile è dove la mutazione sia necessaria e quanto strettamente la si possa confinare.

Fai puntare le dipendenze del codice sorgente verso le regole di business, non verso la tecnologia

Mantieni le regole al centro. Clean Architecture è l’organizzazione del software proposta da Martin, in cui le regole di business restano indipendenti dai meccanismi esterni. Le Entità rappresentano regole di business importanti, applicabili a diverse applicazioni. I Casi d’uso coordinano tali regole per svolgere le attività di una specifica applicazione. Gli adattatori esterni traducono tra queste politiche interne e dettagli quali le richieste web o i record di un database.

Le dipendenze puntano verso l’interno. La Regola delle dipendenze stabilisce che il codice sorgente di un livello interno, dedicato alle regole, non deve fare riferimento né dipendere dai dettagli di implementazione dei livelli esterni. L’attività a runtime può comunque procedere verso l’esterno: un caso d’uso interno chiama un’interfaccia di cui è proprietario, e un presenter esterno o un adattatore per il database implementa tale interfaccia. In questo modo le regole di business possono sopravvivere a un cambiamento del database o del design dello schermo senza ereditare tipi o formati di dati specifici di un framework.

Analisi

La distinzione tra flusso a runtime e dipendenza del codice sorgente è sottile ma potente. Separa chi avvia un’azione da chi può definire il contratto, una distinzione familiare nella progettazione dei protocolli e nella governance istituzionale. Il livello interno è proprietario dell’interfaccia perché è il suo requisito; l’adattatore fornisce un meccanismo sostituibile. Questa disposizione non impone diagrammi concentrici in ogni progetto. È una verifica della titolarità: se cambiare libreria del database obbliga a modificare le regole di business, il confine non sta svolgendo il suo compito.

Traccia i confini in base alle ragioni del cambiamento, non a categorie tecniche arbitrarie

Raggruppa in base alle responsabilità. Il Principio di responsabilità singola afferma che un modulo dovrebbe servire un solo attore, cioè un gruppo che richiede un determinato tipo di modifica. Nell’esempio delle buste paga di Martin, una sola classe Employee contiene il calcolo dei salari, la rendicontazione delle ore e l’archiviazione nel database. Una routine condivisa per le ore può così fare sì che una modifica richiesta dall’ufficio paghe danneggi per errore i report delle risorse umane. Separare il codice in base alle persone e agli scopi che ne richiedono le modifiche riduce queste collisioni.

Progetta per gestire le variazioni in sicurezza. Il Principio aperto-chiuso privilegia l’estensione del comportamento rispetto alla modifica ripetuta del codice protetto. Il Principio di sostituzione di Liskov richiede che implementazioni intercambiabili rispettino le promesse su cui fanno affidamento i loro utilizzatori. Il Principio di segregazione delle interfacce evita di costringere i client a dipendere da operazioni che non usano. Il Principio di inversione delle dipendenze colloca astrazioni stabili tra le regole fondamentali e i dettagli volatili. Nel loro insieme, queste idee aiutano a circoscrivere i cambiamenti, invece di limitarsi ad abbellire le classi.

Analisi

Questi principi sono più efficaci se usati come domande sulla titolarità delle modifiche, non come lista di forme che le classi devono assumere. L’esempio delle buste paga mette in luce un problema tanto sociale quanto tecnico: un team può alterare codice su cui un altro fa affidamento senza rendersene conto. Le interfacce possono rendere esplicita questa titolarità. Tuttavia, suddividere ogni attore in un modulo distinto può creare coordinamento e livelli d’indirezione inutili. I buoni confini seguono differenze ricorrenti nelle modifiche, mentre restano necessari la revisione del codice e la conoscenza del dominio per capire quando due responsabilità divergono davvero.

Elimina i cicli tra componenti prima che trasformino i rilasci in emergenze per tutto il team

I componenti plasmano la collaborazione. Un componente è un’unità distribuibile, come un archivio Java o una libreria condivisa. Tre principi di coesione dei componenti aiutano a decidere cosa debba stare insieme: raggruppare il codice rilasciato insieme, raggruppare il codice che cambia per le stesse ragioni ed evitare di includere classi che gli utenti non hanno bisogno di usare insieme. Questi obiettivi sono in conflitto, quindi la dimensione giusta dei componenti può cambiare man mano che un progetto passa dallo sviluppo interno al riutilizzo.

Mantieni acicliche le dipendenze. Il Principio delle dipendenze acicliche stabilisce che le dipendenze tra componenti formino un grafo orientato senza cicli. Un ciclo può costringere più team a dipendere dallo stesso rilascio sincronizzato, compromettendo i test isolati e l’integrazione incrementale. Anche la stabilità offre un criterio: è costoso modificare i componenti da cui dipendono molti altri, quindi i componenti volatili non dovrebbero diventare prerequisiti per regole stabili. Le interfacce astratte possono invece far puntare le dipendenze verso componenti stabili.

Analisi

Un grafo delle dipendenze è anche una mappa dei costi di coordinamento. I cicli creano l’equivalente software di reparti strettamente interdipendenti, incapaci di modificare le proprie procedure senza negoziare tra loro. Un grafo aciclico non garantisce una buona architettura, ma rende più facile ragionare sull’ordine di compilazione, sull’ambito dei test e sull’impatto dei rilasci. Le metriche di stabilità possono segnalare schemi di dipendenza inattesi, ma non possono stabilire se un componente sia utile o della dimensione appropriata. Sono strumenti diagnostici, non punteggi oggettivi di qualità.

Comincia con un monolite; distribuisci solo quando vincoli reali giustificano il costo

La distribuzione non è architettura. Un monolite può contenere componenti separati con cura, mentre una raccolta di servizi può comunque essere strettamente accoppiata. Le chiamate a funzione all’interno di un singolo processo sono economiche e possono essere frequenti. Le chiamate tra processi o attraverso reti aggiungono latenza, conversione dei dati e modalità di guasto operative, quindi i confini a quei livelli dovrebbero rispondere a un’esigenza reale di sviluppo, distribuzione o gestione.

I servizi non garantiscono indipendenza. Nell’esempio di Martin sulla prenotazione dei taxi, l’aggiunta di un servizio di consegna di gattini incide sulla selezione dei candidati, sull’assegnazione degli autisti, sulle regole dei fornitori e sui controlli delle allergie dei clienti. Suddividere questi comportamenti in servizi non ha impedito alla funzionalità di attraversare tutti quei confini. Un design a componenti con punti di estensione avrebbe potuto isolare la nuova offerta. Il percorso consigliato è preservare prima le separazioni nel codice e poi spostare alcuni confini in unità distribuibili o servizi, quando i dati lo giustificano.

Analisi

È un utile correttivo all’equazione tra distribuzione in rete e modularità. I sistemi distribuiti scambiano la semplicità locale con latenza, guasti parziali, coordinamento delle distribuzioni e requisiti di osservabilità. L’esempio dei gattini mostra che dati condivisi e regole trasversali possono legare i servizi tanto strettamente quanto le funzioni legano le classi. D’altra parte, un monolite può diventare un collo di bottiglia quando i team o i requisiti operativi richiedono davvero distribuzioni indipendenti. La domanda architetturale non è quale topologia sia moderna, ma quale confine riduca i costi complessivi di coordinamento e di guasto nell’ambiente concreto.

Tieni database, interfacce web e framework fuori dalle regole di business

Rimanda le scelte sostituibili. Martin considera dettagli i database, la distribuzione via web e i framework, perché le regole di business non dovrebbero conoscere le loro specifiche implementazioni. In FitNesse, una semplice interfaccia per l’archiviazione delle pagine consentì al team di sviluppare prima le funzionalità usando un’implementazione in memoria, per poi passare ai file di testo. In seguito un cliente aggiunse in circa un giorno un’implementazione MySQL. Alla fine il team non ebbe bisogno di quell’opzione.

Usa gli strumenti senza cedere il controllo del nucleo. I framework possono accelerare il lavoro, ma chi li crea li progetta per i propri problemi e un impegno troppo stretto può rendere costosa la sostituzione in seguito. Mantieni il codice specifico del framework in un adattatore esterno o in un componente di configurazione. Il modello dei dati può essere centrale per l’attività; il software del database e il suo linguaggio di interrogazione non devono necessariamente esserlo. Requisiti esterni di clienti o organizzazioni possono comunque rendere necessaria una tecnologia specifica.

Analisi

La storia di FitNesse dimostra il valore delle decisioni reversibili: una piccola interfaccia mantenne aperta la possibilità di scegliere più avanti, senza obbligare il team a prevedere il sistema di archiviazione perfetto. È un ragionamento simile a quello delle opzioni reali in economia, in cui costi iniziali modesti possono preservare scelte preziose in condizioni d’incertezza. Ma rimandare non è automaticamente saggio. Una decisione tecnologica può incidere su prestazioni, personale, conformità o approvvigionamento, e tali vincoli possono essere sostanziali, non dettati dalla moda. L’obiettivo non è fingere che i vincoli non esistano, ma impedire che contaminino inutilmente le regole di business.

Integra test e confini hardware nell’architettura, invece di aggiungerli dall’esterno

Testa al confine delle regole. Il Pattern dell’oggetto umile (Humble Object) sposta il comportamento difficile da testare in un componente minimo e mantiene la logica in uno testabile. Un presenter può formattare date e importi in un modello di visualizzazione, lasciando alla vista dello schermo il compito di mostrarli. Un’API di test dedicata può consentire ai test di raggiungere le regole di business senza dover navigare un’interfaccia grafica volatile né corrispondere una per una a tutte le classi di produzione. Questo riduce i test fragili e la resistenza a refactoring innocui.

Separa il software dall’hardware. I sistemi embedded hanno bisogno di un livello di astrazione hardware (HAL), un’interfaccia che presenta servizi utili nascondendo l’implementazione specifica del dispositivo. Un’astrazione del sistema operativo può svolgere un ruolo analogo per le dipendenze dal sistema operativo. Senza questi punti di separazione, un cambiamento hardware può imporre modifiche diffuse e il codice potrebbe essere testabile soltanto sul dispositivo di destinazione.

Analisi

Qui la testabilità è una proprietà strutturale, non un ripensamento del team di test. Un’API stabile offre ai test accesso al comportamento, isolandoli dagli aspetti accidentali della disposizione dello schermo e dell’organizzazione delle classi. Nel lavoro sui sistemi embedded, la stessa logica permette di testare prima che l’hardware sia pronto o dopo che un dispositivo diventa obsoleto. Le potenti interfacce di test richiedono attenzione: aggirare la sicurezza o sostituire risorse costose può creare rischi se funzionalità riservate ai test finiscono in produzione. L’isolamento deve includere distribuzione e controllo degli accessi, non soltanto codice sorgente pulito.

Fai emergere il prodotto dall’architettura, poi fai rispettare nel codice i suoi confini

Lascia emergere il dominio. Un repository dovrebbe rendere evidente il proprio scopo, che si occupi di vendita di video, sanità o contabilità, invece di annunciare soltanto il framework web utilizzato. Nel caso della vendita di video, tra gli attori distinti ci sono acquirenti individuali, acquirenti aziendali, autori e amministratori. Raggruppare i loro casi d’uso aiuta a evitare che le richieste di un attore si propaghino indiscriminatamente nel sistema.

L’implementazione può vanificare il design. Nel suo capitolo, Simon Brown confronta l’organizzazione del codice per livello tecnico, funzionalità, confine di dominio o componente. In Java, rendere pubblica ogni classe indebolisce l’incapsulamento a livello di package, perciò il compilatore non può impedire ai chiamanti di aggirare le interfacce previste. Un package organizzato per componenti può esporre un unico punto d’ingresso nascondendo l’implementazione interna. I confini andrebbero rafforzati quando il vantaggio che offrono supera il costo di manutenzione, non imposti ovunque in anticipo.

Analisi

L’architettura comunica sia alle macchine sia alle persone. Una struttura incentrata sul dominio può accelerare l’inserimento dei nuovi arrivati, perché consente loro di intuire cosa faccia il sistema prima di imparare le scelte relative ai framework. Le restrizioni di accesso imposte dal compilatore rendono quella struttura qualcosa di più di un diagramma o di una promessa fatta in revisione del codice. Tuttavia, organizzare il codice per funzionalità o componenti non è sempre la scelta migliore; le regole di visibilità del linguaggio, le dimensioni del team e le esigenze di distribuzione determinano l’assetto più adatto. Il criterio fondamentale è se la struttura scelta renda facili le dipendenze previste e difficili quelle accidentali.

Analisi

La mossa più importante del libro consiste nel ridefinire l’architettura: non più un diagramma di riquadri, ma una strategia per gestire il costo dei cambiamenti. In questo modo, le sue raccomandazioni si integrano in un insieme coerente: l’inversione delle dipendenze protegge le politiche, i grafi dei componenti organizzano la collaborazione, i confini verificabili limitano il rischio di regressioni e rimandare le scelte tecnologiche preserva le opzioni. L’argomentazione è più convincente quando collega la struttura del software all’impegno umano. Un grafo delle dipendenze intricato non è soltanto esteticamente poco gradevole: rallenta l’integrazione, amplia l’onere dei test e richiede più persone per apportare modifiche ordinarie.

Il suo modello è volutamente applicabile a linguaggi ed epoche diverse. Gli elementi fondamentali ricorrenti sono sequenza, selezione, iterazione, dati e indirezione, mentre hardware e strumenti cambiano. Questa prospettiva storica contrasta opportunamente l’idea che un nuovo framework o uno stile di distribuzione diverso risolvano i vecchi problemi di progettazione. Tuttavia, l’affermazione secondo cui le regole architetturali sono sostanzialmente immutabili va intesa come un riferimento a principi durevoli, non a implementazioni identiche. Le moderne piattaforme distribuite, le operazioni cloud e i vincoli normativi modificano il profilo dei costi dei confini, anche quando le politiche dovrebbero restare al riparo dai dettagli.

Il libro propone anche una tensione feconda, non una ricetta. Riuso, possibilità di apportare modifiche localizzate ed evitare dipendenze superflue spingono la progettazione dei componenti in direzioni diverse. Allo stesso modo, prevedere un confine può evitare interventi costosi, ma un’astrazione speculativa può gravare su un prodotto di piccole dimensioni. Il compito architetturale è dunque empirico: osservare dove i cambiamenti entrano in conflitto, dove i test diventano fragili e dove la distribuzione o l’esercizio impongono vincoli reali, poi investire nel confine i cui risparmi attesi giustificano i costi di manutenzione.

Alcune prove sono illustrative, più che conclusive. Il caso sulla produttività si basa sulle righe di codice e l’esperimento sullo sviluppo guidato dai test è di portata limitata. Nessuno dei due dimostra un ritorno numerico universale derivante da una progettazione pulita. Servono piuttosto a rendere visibile un meccanismo plausibile: una struttura disordinata assorbe energie che altrimenti potrebbero produrre funzionalità utili. La lezione duratura non è massimizzare l’astrazione, bensì rendere le politiche importanti del sistema comprensibili, verificabili e relativamente insensibili ai dettagli che hanno maggiori probabilità di cambiare.

Riassunto in 30 secondi
L’architettura determina quanto lavoro richiedono le modifiche ordinarie nel corso della vita di un sistema. Mantieni le regole aziendali indipendenti da database, interfacce e framework, e orienta le dipendenze del codice verso tali regole. Separa i moduli in base alle responsabilità, previeni le dipendenze circolari e definisci confini dove le modifiche entrano in conflitto o i test diventano fragili. Parti da un monolite ben separato; passa a servizi distribuiti solo quando vincoli operativi o di sviluppo ne giustificano i costi. In un’azienda, la produzione di codice è cresciuta a malapena mentre il personale aumentava; nelle versioni successive, ogni riga è arrivata a costare circa 40 volte di più.
Contiene spoiler

Ultimo aggiornamento:

Segnala un problema

Sintesi delle recensioni

4.21 su 5
Media di 7.000+ valutazioni da Goodreads e Amazon.

Clean Architecture: A Craftsman's Guide to Software Structure and Design riceve giudizi contrastanti. Molti ne apprezzano l’attenzione ai Principi SOLID e al disaccoppiamento, mentre altri lo trovano ripetitivo e privo di esempi pratici. Alcuni lettori apprezzano il contesto storico e gli aneddoti, mentre altri ritengono che distolgano dai contenuti fondamentali. In generale, il libro è considerato utile per comprendere i concetti architetturali di alto livello, ma le opinioni divergono sulla sua utilità per i principianti rispetto agli sviluppatori esperti. Diversi recensori osservano che i contenuti avrebbero potuto essere esposti in modo più conciso.

La tua valutazione:
4.6
633 valutazioni
Vuoi leggere il libro completo?

Glossario

Architettura pulita (Clean Architecture)

Politiche isolate dai dettagli

Un approccio architetturale che colloca all’interno le importanti politiche aziendali e all’esterno i meccanismi tecnici, come database, framework web e dispositivi. Le dipendenze del codice sorgente puntano verso le politiche interne. Il sistema può comunque usare strumenti esterni, ma le regole fondamentali non dovrebbero dipendere dai loro nomi, formati o scelte implementative.

Regola delle dipendenze

Le dipendenze puntano verso le politiche

La regola secondo cui, in un’architettura a livelli, le dipendenze del codice sorgente devono puntare verso l’interno, dai dettagli alle politiche di livello più alto. Il codice interno non deve fare riferimento a nomi o formati di dati dichiarati dai livelli esterni. Le interfacce di proprietà del codice interno consentono alle chiamate in fase di esecuzione di raggiungere implementazioni esterne senza invertire la dipendenza del codice sorgente.

Entità

Regole e dati aziendali fondamentali

Un oggetto o modulo software che riunisce dati aziendali critici e le regole che li governano. Un’Entità rappresenta un concetto aziendale che conserva il proprio significato al di là dell’interfaccia o del database di una specifica applicazione. Non dovrebbe dipendere da questi meccanismi tecnici.

Caso d’uso

Procedura aziendale specifica dell’applicazione

Descrizione e implementazione del modo in cui si usa un sistema automatizzato per raggiungere un obiettivo. Un caso d’uso definisce input, output ed elaborazione pertinenti e coordina le Entità che contengono regole aziendali più generali. Non dovrebbe dipendere dal fatto che gli utenti interagiscano tramite una pagina web, una console o un’altra interfaccia.

Principi SOLID

Linee guida per una progettazione che agevola le modifiche

Cinque principi di progettazione correlati, che riguardano responsabilità, estensione, sostituibilità, dimensione delle interfacce e direzione delle dipendenze. Guidano il modo in cui vengono raggruppati funzioni e dati e in cui i moduli dipendono gli uni dagli altri. Il loro obiettivo comune è rendere il software più facile da modificare, comprendere e riutilizzare, evitando di accoppiare responsabilità non correlate.

Principi di coesione dei componenti

Regole per raggruppare codice distribuibile

I principi di equivalenza tra riuso e rilascio, chiusura comune e riuso comune guidano la scelta delle classi da includere in un componente. Bilanciano il rilascio coordinato, il raggruppamento del codice che cambia per gli stessi motivi e l’evitare dipendenze da classi inutilizzate. Poiché questi obiettivi possono entrare in conflitto, la struttura dei componenti dovrebbe rispecchiare le attuali esigenze di sviluppo e riuso del progetto.

Event sourcing

Memorizzare gli eventi e ricavarne lo stato attuale

Una strategia per i dati che memorizza la sequenza di transazioni o eventi, anziché sovrascrivere ripetutamente lo stato attuale. Lo stato viene ricostruito applicando tali eventi, talvolta a partire da uno snapshot salvato per ridurre il lavoro di rielaborazione. Può ridurre gli aggiornamenti mutabili, ma richiede spazio e capacità di elaborazione per la cronologia registrata.

Pattern dell’oggetto umile (Humble Object)

Separare il comportamento difficile da testare

Un pattern di progettazione che suddivide il comportamento tra un componente minimo, incaricato di gestire gli aspetti difficili da testare, e un componente separato che contiene la logica verificabile. Per esempio, una vista può mostrare valori già preparati, mentre un presenter si occupa di formattarli. Questa separazione crea spesso un utile confine architetturale.

API di test

Accesso stabile per i test automatizzati

Un’interfaccia pensata per consentire ai test di verificare il comportamento aziendale senza dipendere dall’interfaccia utente né riprodurre ogni classe di produzione. Può offrire modi controllati per impostare lo stato del sistema, evitare risorse costose o accedere a operazioni non disponibili agli utenti comuni. Le funzionalità di test sensibili dovrebbero essere escluse dai percorsi di accesso alla produzione.

Livello di astrazione hardware (HAL)

Hardware nascosto dietro servizi

Un’interfaccia software che presenta i servizi necessari a un’applicazione, nascondendo i dettagli di hardware specifici. Invece di esporre registri del dispositivo o assegnazioni dei pin, può offrire operazioni espresse in termini di prodotto. Le implementazioni possono così cambiare insieme all’hardware, mentre il software di livello superiore rimane isolato.

Sequenza principale (Main Sequence)

Bilanciare stabilità e astrazione

Una linea su un grafico di progettazione dei componenti che mette in relazione stabilità e astrazione. I componenti vicini a un’estremità sono stabili e astratti; quelli vicini all’altra sono instabili e concreti. I componenti lontani dalla linea possono essere rigidi pur essendo concreti, oppure astratti senza dipendenti utili. La misura è uno spunto diagnostico, non una prova di qualità.

FAQ

Di cosa parla Clean Architecture?

  • Attenzione alla struttura del software: Clean Architecture di Robert C. Martin sottolinea l’importanza di creare sistemi facili da sviluppare, mantenere e distribuire grazie a un’architettura software efficace.
  • Principi senza tempo: illustra principi come SOLID, applicabili a diversi paradigmi di programmazione, per guidare gli sviluppatori nella scrittura di codice pulito e manutenibile.
  • Separazione delle responsabilità: il libro sostiene la separazione delle regole aziendali dai dettagli tecnici, aumentando flessibilità e adattabilità nella progettazione del software.

Perché dovrei leggere Clean Architecture?

  • Migliorare le competenze di progettazione software: il libro approfondisce la comprensione dell’architettura software e offre consigli pratici per i progetti reali.
  • Conoscenze senza tempo: i suoi principi non sono legati a tecnologie specifiche e restano pertinenti nel corso della carriera.
  • Esempi dal mondo reale: Martin condivide spunti tratti dalla sua vasta esperienza e propone esempi e casi di studio accessibili per semplificare concetti complessi.

Quali sono i concetti fondamentali di Clean Architecture?

  • L’architettura è una struttura: l’architettura software è definita dalla suddivisione in componenti e dalle loro comunicazioni, che agevolano lo sviluppo e la manutenzione.
  • Disaccoppiare le regole aziendali: si sottolinea l’importanza di separare le regole aziendali dai dettagli tecnici per agevolare modifiche e adattamenti.
  • Lasciare aperte le opzioni: una buona architettura rimanda le decisioni tecniche, mantenendo la flessibilità necessaria per adattarsi ai requisiti in evoluzione.

Quali sono i Principi SOLID citati in Clean Architecture?

  • Principio di responsabilità unica (SRP): una classe dovrebbe avere un solo motivo per cambiare; questo riduce la complessità e semplifica la manutenzione.
  • Principio aperto/chiuso (OCP): le entità software dovrebbero essere aperte all’estensione ma chiuse alle modifiche, riducendo al minimo il rischio di bug.
  • Principio di sostituzione di Liskov (LSP): i sottotipi devono poter sostituire i tipi base senza compromettere la correttezza del programma.

Che cos’è il Principio di inversione delle dipendenze (DIP) in Clean Architecture?

  • Moduli di alto livello: il DIP afferma che i moduli di alto livello non dovrebbero dipendere da quelli di basso livello; entrambi dovrebbero dipendere da astrazioni.
  • Astrazioni al posto dei dettagli: dipendere da astrazioni anziché da implementazioni concrete rende i sistemi più facili da modificare ed estendere.
  • Uso delle interfacce: incoraggia l’uso di interfacce per definire contratti tra componenti, facilitando test e manutenzione.

Come definisce Clean Architecture una buona architettura software?

  • Supporto ai casi d’uso: una buona architettura deve supportare i casi d’uso previsti, rendendoli chiari e visibili nella struttura.
  • Ridurre al minimo le risorse umane: grazie a una progettazione attenta, dovrebbe ridurre al minimo le risorse necessarie per sviluppo, distribuzione e manutenzione.
  • Lasciare aperte le opzioni: un’architettura ben progettata mantiene aperte le possibilità di cambiamento futuro, aspetto fondamentale per il successo a lungo termine.

Qual è il significato dei confini in Clean Architecture?

  • Separazione delle responsabilità: i confini separano i componenti del sistema, assicurando che le modifiche in un’area non abbiano effetti negativi sulle altre.
  • Controllo delle dipendenze: gestire le dipendenze tra i confini previene le interruzioni e contribuisce alla stabilità del sistema.
  • Favorire lo sviluppo indipendente: i confini consentono ai team di lavorare in autonomia, aumentando la produttività e riducendo i conflitti.

Che cos’è il concetto di «Screaming Architecture» in Clean Architecture?

  • L’architettura riflette l’intento: «Screaming Architecture» significa che l’architettura del sistema dovrebbe comunicare chiaramente il suo scopo e le sue funzionalità.
  • Guidata dai casi d’uso: una buona architettura è guidata dai casi d’uso e mantiene chiarezza e finalità durante tutto lo sviluppo.
  • Evitare la dipendenza dai framework: l’architettura dovrebbe essere incentrata sulle esigenze aziendali, non dettata da framework o strumenti.

In che modo Clean Architecture affronta i test?

  • Architetture verificabili: sottolinea l’importanza di architetture che consentano di testare le regole aziendali senza dover eseguire sistemi esterni.
  • Pattern dell’oggetto umile (Humble Object): separa il codice difficile da testare da quello verificabile, concentrandosi sulla logica senza le complessità dell’interfaccia utente o dei framework.
  • API di test: suggerisce di creare un’API di test per aggirare i vincoli di sicurezza, aumentando la possibilità di verificare diversi scenari.

Come distingue Clean Architecture il web dall’architettura di un sistema?

  • Il web come meccanismo di distribuzione: il web è considerato un meccanismo di distribuzione, non un aspetto che definisce l’architettura del sistema.
  • Disaccoppiare la distribuzione dalla logica: trattare il web come un dettaglio consente di progettare sistemi indipendenti dai metodi di distribuzione.
  • Attenzione alla logica aziendale: dà priorità alla logica aziendale e ai casi d’uso rispetto ai dettagli della distribuzione via web, garantendo che le funzionalità fondamentali rimangano intatte.

Quali rischi comporta l’uso dei framework secondo Clean Architecture?

  • Accoppiamento stretto: i framework possono creare un accoppiamento stretto e rendere difficile passare a un’altra tecnologia.
  • Sovraccarico e complessità: un’eccessiva dipendenza dai framework può introdurre complessità superflua e ostacolare le prestazioni.
  • Perdita di controllo: affidarsi troppo ai framework può rendere rigido il sistema e complicare modifiche e adattamenti.

Quali sono le citazioni migliori di Clean Architecture e che cosa significano?

  • «La tua architettura dovrebbe parlare ai lettori del sistema, non dei framework che hai usato nel sistema.»: sottolinea che l’architettura dovrebbe riflettere il dominio aziendale e i casi d’uso, non le tecnologie.
  • «I framework sono strumenti, non modi di vivere.»: ricorda agli sviluppatori di mantenere il controllo sull’architettura e di non dipendere eccessivamente dai framework.
  • «Una buona architettura rende superfluo decidere se usare Rails, Spring, Hibernate, Tomcat o MySQL fino a una fase molto più avanzata del progetto.»: evidenzia i vantaggi di rimandare le decisioni tecnologiche finché l’architettura non è stata definita, favorendo la flessibilità.

Sull'autore

Robert Cecil Martin, noto come Uncle Bob, è un eminente ingegnere del software e sostenitore dei metodi di sviluppo Agile. In qualità di presidente di Object Mentor Inc., guida un team di consulenti specializzati in progettazione orientata agli oggetti, pattern, UML e metodologie Agile. Martin ha una vasta esperienza nel settore del software e dal 1996 al 1999 è stato caporedattore di C++ Report. È un relatore molto richiesto a conferenze e fiere internazionali, dove condivide la propria esperienza sulle migliori pratiche di sviluppo software. La sua influenza va oltre la consulenza: ha scritto diversi libri importanti sulla maestria artigianale del software e sulle pratiche di programmazione pulita.

Scarica PDF

Per conservare questo riassunto di Clean Architecture e leggerlo in seguito, scarica il PDF gratuito. Puoi stamparlo o leggerlo offline quando vuoi.
Download PDF

Scarica EPUB

Per leggere il riassunto di Clean Architecture sul tuo e-reader o sulla relativa app, scarica l’EPUB gratuito. Il formato digitale .epub è ideale per leggere ebook su telefoni, tablet ed e-reader.
Download EPUB
Vuoi leggere il libro completo?
Segui
Ascolta
Home
Swipe
Libreria
App
Prova l'accesso completo per 3 giorni
Ascolta, salva e molto altro
Confronta le funzionalità Gratuito Pro
📖 Leggi i riassunti
Leggi riassunti illimitati. Gli utenti gratuiti ne ricevono 3 al mese
🎧 Ascolta i riassunti
Ascolta riassunti illimitati in 40 lingue
—
❤️ Segnalibri illimitati
Gli utenti gratuiti sono limitati a 4
—
📜 Cronologia illimitata
Gli utenti gratuiti sono limitati a 4
—
📥 Download illimitati
Gli utenti gratuiti sono limitati a 1
—
Prova senza rischi
Oggi: accesso immediato
Ascolta i riassunti completi di oltre 26.000 libri. Sono più di 12.000 ore di audio!
Giorno 2: promemoria della prova
Ti invieremo una notifica per avvisarti che la prova sta per scadere.
Giorno 3: inizia il tuo abbonamento
L'addebito avverrà il 24 nov,
puoi annullare in qualsiasi momento prima.
Consume 2.8× More Books
2.8× libri in più Ascolto Lettura
I nostri utenti ci adorano
1M+ lettori
Trustpilot Rating
TrustPilot
4.6 Eccellente
Questo sito è una vera rivoluzione. Ho letto riassunti di libri come mai prima d'ora. Consigliatissimo.
— Dave G
Vale ogni centesimo e ogni minuto, ed è davvero ben fatto. Non ho mai visto riassunti di questa qualità su altri siti. Utilissimo!
— Em
Consigliatissimo!! Servizio fantastico. Perfetto per chi vuole qualcosa in più di un'anteprima ma senza tutti i dettagli di un audiolibro completo.
— Greg M
Risparmia il 62%
Annuale
$119.88 $44.99/anno/anno
$3.75/mese
Mensile
$9.99/mese
Inizia la prova gratuita di 3 giorni
3 giorni gratis, poi $44.99/anno. Cancella quando vuoi.
Unlock a world of fiction & nonfiction books
Oltre 26.000 libri al prezzo di 2
Leggi qualsiasi libro in 10 minuti
Scopri nuovi libri come su Tinder
Richiedi qualsiasi libro se non è ancora disponibile
Leggi più libri di chiunque tu conosca
App n. 1 per gli amanti dei libri
Lifelike & immersive summaries
Garanzia di rimborso entro 30 giorni
Scarica i riassunti in EPUB o PDF
Cancella in qualsiasi momento con pochi clic

Perché un solo riassunto?

Scanner
Trova un codice a barre da scansionare

⭐
⭐
⭐
Abbiamo un regalo speciale per te
Apri
38% di sconto
SCONTO PER TE
⭐
⭐
⭐
$79.99
$49.99/anno
Solo $4.16 al mese
Continua
Bastano 2 tocchi per iniziare, cancellare è facilissimo
Impostazioni
Generali
Widget
Caricamento...