Scroll Top
Via Antonio Amato, 20/22 84131 Salerno (SA)

Introduzione al Clean Code – Parte 2

clean code

(articolo redatto da Gaetano De Pascale)

Benvenuti al secondo appuntamento della nostra mini serie dedicata al Clean Code. esploreremo l’importanza della struttura e dell’organizzazione del codice, nonché delle principali filosofie come SOLID, DRY, YAGNI e KISS, e della gestione degli errori.

Nel primo articolo, abbiamo introdotto la filosofia del Clean Code, evidenziando l’importanza di attribuire nomi descrittivi e consistenti alle variabili, alle funzioni e alle classi. Abbiamo compreso come una buona nomenclatura sia fondamentale per migliorare la leggibilità del codice e favorire una maggiore comprensione da parte degli sviluppatori.

Argomenti trattati

In questo secondo articolo ci concentreremo sull’organizzazione del codice.

Vedremo come una struttura ben definita e coerente possa facilitare la manutenzione e l’estendibilità del software.

Esploreremo le principali filosofie del Clean Code, quali:

  • SOLID (Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, Dependency Inversion Principle)
  • DRY (Don’t Repeat Yourself)
  • YAGNI (You Aren’t Gonna Need It)
  • KISS (Keep It Simple, Stupid)

e vedremo come applicarle per ottenere un codice di qualità superiore.

Inoltre, affronteremo la gestione degli errori. Impareremo come gestire le eccezioni in modo efficace, affinché il nostro software sia in grado di reagire in modo appropriato in caso di situazioni anomale. Esploreremo le migliori pratiche per la gestione degli errori, compreso l’uso di eccezioni personalizzate, la registrazione degli errori e la gestione delle risorse in modo sicuro.

Il nostro obiettivo è fornirvi le conoscenze e gli strumenti necessari per scrivere codice pulito, leggibile e manutenibile. L’organizzazione del codice, l’applicazione delle filosofie del Clean Code e una corretta gestione degli errori sono elementi essenziali per creare software di qualità che possa evolversi nel tempo.

Struttura e organizzazione del codice

Un altro aspetto importante per garantire un codice pulito e manutenibile è la sua corretta struttura e organizzazione. Una buona pratica è suddividere il codice in moduli o file separati, ognuno con una responsabilità chiara e ben definita. Ad esempio, possiamo creare moduli separati per la gestione dei dati, la logica di business e l’interfaccia utente. Ciò facilita la comprensione del flusso del programma e permette di individuare e risolvere problemi in modo più efficiente.

Inoltre, una buona pratica è quella di utilizzare convenzioni di denominazione coerenti per i moduli, le classi e i metodi. Ad esempio, possiamo seguire la convenzione di denominazione PascalCase per i nomi di classe e metodo, mentre camelCase per le variabili e i parametri. Ciò rende il codice più leggibile e facilita la comprensione della struttura del programma. Infine, l’utilizzo di un approccio logico nell’organizzazione del codice, come la separazione dei livelli di astrazione o la definizione di interfacce chiare, contribuisce a una migliore manutenibilità del codice.

La struttura e l’organizzazione del codice sono fondamentali per creare un ambiente di sviluppo pulito e intuitivo, consentendo una migliore collaborazione tra gli sviluppatori e semplificando l’aggiornamento e la manutenzione del software nel tempo.

Seguimi!

Principi SOLID

I principi SOLID (Single responsibility principle, Open-closed principle, Liskov Substitution Principle, Interface segregation principle, Dependency inversion principle) sono un insieme di linee guida che promuovono un design di codice pulito, flessibile e facilmente estendibile.

Rimandiamo l’approfondimento di questi principi ad un precedente articolo che potete trovare qui

DRY – KISS – YAGNI

L’applicazione dei principi DRY, KISS e YAGNI è fondamentale per la scrittura di un codice pulito e manutenibile.

  • DRY (Don’t Repeat Yourself): “Evita il codice duplicato

Sottolinea l’importanza di evitare la duplicazione di codice. Ripetere il codice può portare a problemi di manutenzione e leggibilità, nonché a un aumento della complessità complessiva del software.

Per eliminare il codice duplicato, è possibile utilizzare diverse tecniche. Una delle più comuni è estrarre il codice duplicato in una funzione o un metodo separato e richiamarlo ogni volta che è necessario. In questo modo, il codice viene centralizzato in un’unica posizione, rendendo più facile apportare modifiche o correzioni.

Un altro approccio è quello di utilizzare l’ereditarietà o la composizione per condividere il codice comune tra classi o moduli. Definendo una gerarchia di classi o utilizzando un componente riutilizzabile, è possibile evitare la duplicazione di codice e promuovere una struttura modulare.

  • KISS (Keep It Simple, Stupid): “Sii sempre il più semplice possibile

Suggerisce di mantenere il codice semplice e comprensibile. Una soluzione semplice è sempre preferibile ad una complessa, in quanto è più facile da comprendere e mantenere nel tempo. Evitare l’eccesso di complessità nel design e nella logica del codice aiuta a ridurre il rischio di bug e semplifica la collaborazione tra gli sviluppatori.

  • YAGNI (You Ain’t Gonna Need It): Togliere quello che non serve

Si riferisce alla pratica di evitare l’implementazione di funzionalità non necessarie. L’aggiunta di funzionalità inutilizzate o non richieste può aumentare la complessità del codice e renderlo più difficile da mantenere. Invece, è consigliabile implementare solo ciò di cui si ha effettivamente bisogno, in base ai requisiti del progetto. Ciò permette di mantenere un codice più leggero, più semplice da comprendere e con meno probabilità di bug.

Applicare i principi DRY, KISS e YAGNI nel Clean Code consente di creare un codice più pulito, leggibile e manutenibile. Riducendo la duplicazione del codice, mantenendo la semplicità del design e evitando l’implementazione di funzionalità non necessarie, si promuove un codice più efficiente, meno soggetto a errori e più facile da comprendere. Questi principi favoriscono una migliore qualità del software, facilitano la collaborazione tra gli sviluppatori e semplificano il processo di manutenzione nel lungo termine.

Gestione degli errori

La gestione degli errori è un aspetto essenziale per scrivere un codice pulito e robusto.

  • Utilizzare eccezioni: le eccezioni sono uno strumento potente per gestire gli errori. Quando si verificano situazioni impreviste, ad esempio un input non valido, un errore di sistema o una situazione di errore di runtime, è consigliabile utilizzare eccezioni per segnalare l’errore. In questo modo, si può interrompere l’esecuzione del programma in modo controllato e gestire l’errore in modo appropriato.
  • Separare la gestione degli errori dalla logica di business: è importante separare la logica di business dalla gestione degli errori per migliorare la leggibilità e la manutenibilità del codice. Ciò significa che la logica di business dovrebbe essere scritta in modo da evitare di generare errori e la gestione degli errori dovrebbe essere separata in una sezione del codice dedicata alla gestione degli errori.
  • Evitare l’utilizzo di valori di ritorno speciali: utilizzare valori di ritorno speciali per gestire gli errori può rendere il codice più complicato e difficile da leggere. Utilizzare, invece, le eccezioni per segnalare gli errori in modo chiaro e definito.
  • Registrare gli errori: registrare gli errori è importante per la risoluzione dei problemi e la manutenzione del software. Ciò significa che gli errori dovrebbero essere registrati in modo che possano essere facilmente identificati e risolti.
  • Gestire gli errori in modo appropriato: la gestione degli errori dovrebbe essere progettata in modo da essere appropriata per l’applicazione specifica. Ciò significa che dovrebbe essere adattata alle esigenze dell’applicazione e del contesto in cui viene utilizzata.

È importante prevedere e gestire correttamente gli errori che possono verificarsi durante l’esecuzione del programma. Una buona pratica è quella di utilizzare try-catch blocks per catturare e gestire gli errori in modo controllato. Questo permette di eseguire azioni appropriate in caso di errori, come la registrazione delle informazioni di errore, la comunicazione all’utente o la ripresa dell’esecuzione del programma in uno stato coerente. È fondamentale evitare di nascondere gli errori o di semplicemente ignorarli, in quanto ciò può causare comportamenti imprevisti e problemi difficili da individuare. Inoltre, è consigliabile definire e utilizzare messaggi di errore chiari e significativi.

Conclusioni

In questo articolo abbiamo esplorato l’importanza dell’organizzazione del codice e i principi che sono alla base della filosofia. Abbiamo, inoltre, anche affrontato il tema cruciale della gestione delle eccezioni, sottolineando l’importanza di identificare e gestire correttamente gli errori all’interno del nostro codice, garantendo una corretta separazione della logica, ed una corretta fase di logging.

Nel prossimo articolo, esploreremo l’importanza dei test del codice, degli strumenti e delle pratiche aggiuntive per garantire la qualità del nostro software. Vedremo come i test automatizzati ci consentono di verificare il corretto funzionamento delle nostre implementazioni e di individuare eventuali regressioni.


Se anche tu vuoi occuparti di importanti progetti di sviluppo software
dai un’occhiata alle nostre opportunità di lavoro e conosciamoci subito!