La leggibilità del codice

Codice illeggibile?

The rationale for the code being the primary source of documentation is that it is the only one that is sufficiently detailed and precise to act in that role [….].

This principle comes with a important consequence – that it’s important that programmers put in the effort to make sure that this code is clear and readable.

Martin Fowler – CodeAsDocumentation

Di solito gli sviluppatori non dedicano particolare attenzione alla scrittura della documentazione. Nel caso migliore è vista come un male necessario, nel caso peggiore invece è trattata come un task da fare il più tardi possibile (e tendenzialmente mai).

Recentemente, grazie alla diffusione di metodologie agili, la scrittura della documentazione sta diventando parte integrante del processo di sviluppo di un software. Infatti il processo di scrittura e di mantenimento della documentazione può essere semplificato inserendola all’interno del codice stesso. In questo modo il codice assume il ruolo di sorgente principale di documentazione di un progetto.

In questo articolo ti voglio parlare dell’importanza di mantenere una documentazione a scopo interno che sia ben fatta, con un codice che sia “parlante” e con il giusto numero di commenti. Per farlo cercherò di rispondere alle seguenti 3 domande:

  • Perché il codice deve essere leggibile?
  • Quando è che un codice è leggibile?
  • Come scrivo codice che sia leggibile?

Ma prima di rispondere a queste domande mi presento, sono Lorenzo Millucci e sono un ingegnere del software che ama lavorare con Symfony e a cui piace condividere in questo blog le cose che impara. Iscriviti al mio canale Telegram per non perderti nessuna notizia!

Perché il codice deve essere leggibile?

Affrontiamo subito l’elefante nella stanza: perché devo prendermi la bega di scrivere del codice che sia leggibile?

Lo sviluppo di software è un task che viene affrontato in team nella quasi totalità dei casi. Ormai quasi nessun progetto viene sviluppato da una singola persona. Questo vuol dire che il codice che oggi io scrivo da solo davanti al mio PC prima o poi dovrà essere letto e capito da altri sviluppatori in modo che possano modificarlo per correggere bug o per aggiungere nuova funzionalità.

Quando il codice non è facilmente leggibile, lo sviluppatore che dovrà modificare dopo di me quelle righe dovrà perdere una notevole quantità di tempo solo per capire cosa ho fatto e come l’ho fatto per quello che magari poteva essere un fix facile e veloce.

Nel caso peggiore il codice scritto potrebbe essere così astruso che uno sviluppatore, piuttosto che perdere tempo nel cercare di decifrarlo, potrebbe decidere di riscriverlo da capo. Ma il processo di riscrittura non è esente da rischi. Infatti non è raro che qualche edge-case particolare non venga coperto dal nuovo codice o che venga introdotto qualche bug che il codice originale non aveva. Tutto ciò rende quindi necessario iterare più e più volte il processo di scrittura aumentando notevolmente i tempi e i costi di sviluppo.

Un altro fenomeno che spesso si verifica quando il codice non è facilmente interpretabile dagli sviluppatori è quello chiamato “Shanghai programming”.
Hai presente il gioco Shanghai? Quello in cui c’è un mucchio di bastoncini e i giocatori si sfidano a chi ne sfila il numero maggiore senza muovere gli altri.
Bene, può accadere la stessa cosa nello sviluppo di un software. Uno sviluppatore, non riuscendo a capire cosa faccia il mio codice, potrebbe essere portato a cambiare solamente le parti strettamente necessarie ad implementare la funzionalità richiesta senza toccare il resto. Questo comportamento non può che portare ad un’ulteriore riduzione della leggibilità del codice.

Arrivati a questo punto non devi stupirti del fatto che il codice non leggibile sia uno dei più grandi contribuenti all’aumento incontrollato del debito tecnico.

Ora che hai capito il perché il codice deve essere facilmente leggibile da chiunque procediamo a chiarire quando è che un codice è leggibile (e di conseguenza quando non lo è).

Malore: La tipica reazione di uno sviluppatore di fronte ad un codice illeggibile
La tipica reazione di uno sviluppatore di fronte ad un codice illeggibile

Quando è che un codice è leggibile?

Sfortunatamente non esiste una risposta universale a questa domanda. A seconda del linguaggio utilizzato, del team o della singola persona presa in considerazione la risposta a questa domanda varia.

Quello che sicuramente possiamo dire è che un codice è illeggibile se non è formattato in modo coerente.
Ti è mai capitato di aprire un libro e vedere una pagina fitta-fitta di testo senza alcuna suddivisione in paragrafi? Quando succede a me la prima reazione è quella di chiudere il libro e lasciare perdere la lettura. Questa è la stessa reazione di uno sviluppatore che vede un codice mal-formattato.

Quindi una prima costatazione da fare è che per aumentare la leggibilità del codice è necessario stabilire delle convenzioni da seguire per l’impaginazione/formattazione del codice. Ad esempio definire che tutti i metodi devono essere scritti in camelCase. Oppure che l’indentazione del codice deve essere fatta utilizzando gli spazi piuttosto che tabulazioni. Ecc…
Tipicamente per queste regole stilistiche ci vengono incontro vari tool automatici di analisi statica che, una volta definite le regole, evidenziano (e a volte correggono automaticamente) tutti gli errori che incontrano.

Ma è sufficiente definire delle regole stilistiche per scrivere del codice leggibile? Ovviamente la risposta è no.

Una volta che il codice è ben formattato bisogna iniziare a vedere che ciò che abbiamo scritto sia comprensibile anche agli altri membri del team di sviluppo.

La prima cosa da fare in questo caso è farsi una serie di domande:

  • Si riesce a seguire il flusso del codice?
  • Il nome di un metodo/variabile aiuta a capire a cosa serve?
  • E’ necessario aggiungere un commento ulteriore per chiarire cosa sto facendo?
  • ecc…

Una volta terminata questa fase di “auto-analisi” del codice posso finalmente affermare che il codice è chiaramente leggibile da me stesso.

Ma come dicevamo all’inizio orma si lavora sempre in team e quindi non è sufficiente che il codice che ho scritto sia leggibile da me ma deve essere leggibile da qualunque altro collega.

Ecco quindi la prova finale per garantire la leggibilità di un software: superare la code-review.

Solo nel caso in cui un altro sviluppatore sia effettivamente in grado di capire cosa fa il mio codice senza porre domande sul suo funzionamento e senza fraintenderne in alcun modo il flusso logico posso dire di aver prodotto un codice veramente leggibile.

Reazione di festeggiamento quando finalmente la code review passa
Finalmente il codice è leggibile

Come scrivo codice che sia leggibile?

Anche a questa domanda non esiste una risposta universalmente riconosciuta. Tuttavia alcuni principi da avere bene a mente durante lo sviluppo del software sono:

  • Single-responsibility principle (SRP): ogni elemento di un programma deve avere una e una sola responsabilità. In modo tale che per uno sviluppatore sia facile capire cosa andare a modificare in caso di necessità.
  • Don’t repeat yourself (DRY): ogni elemento di un programma deve essere scritto una e una sola volta all’interno della code-base. Deve esistere una sola fonte di verità in modo da garantire che la modifica di un blocco di codice non debba mai essere ripetuta in più volte in più punti dell’applicazione.
  • Naming significativo: i nomi degli attributi, delle funzioni e delle classi deve essere significativo ed essere pensato in modo tale da aiutare la comprensione del codice.
  • Commenti solo se necessari: con un buon naming si può fare a meno di molti blocchi di commenti. Tuttavia esistono porzioni di codice che richiedono ulteriori spiegazioni e che quindi devono essere necessariamente commentate. I buoni commenti spiegano il “perché” di una determinata scelta. Il “come” è spiegato dal codice.
  • Testing: sebbene i test automatici non migliorino direttamente la leggibilità di un blocco di codice, questi permettono di capire il contesto in cui il codice è utilizzato. Inoltre, anche con il codice più leggibile del mondo è facile incappare in errori. Solo con una suite di test automatici in grado di coprire tutto il software è possibile modificare un software senza il terrore di aver rotto qualcosa nel tentativo di aggiustare qualcos’altro.

Conclusioni

Spero che questo articolo ti abbia aiutato a capire “perché”, “quando” e “come” scrivere un codice leggibile. Sicuramente ha aiutato me a mettere in ordine varie idee e nozioni che avevo acquisito ma che non avevo mai avuto modo di organizzare in modo strutturato.

Come hai potuto leggere nel corso dell’articolo alla base di un codice leggibile non c’è nessun concetto astratto o complesso da capire. Si tratta di nozioni che chiunque abbia provato a programmare con un qualunque linguaggio conosce ma che di solito si tende a dimenticare in quanto concetti considerati banali.

Un ulteriore punto che ci tengo a precisare è che la perfezione non esiste. Esisterà sempre un modo più ricercato o più elegante per rendere maggiormente leggibile una porzione di codice.
Il problema è che poiché la leggibilità non è un concetto universalmente definito dagli sviluppatori si possono creare delle situazioni di stallo in cui opinioni differenti rischiano di bloccare completamente lo sviluppo. Proprio per evitare di cercare la perfezione a tutti i costi è fondamentale tenere a mente che molte volte è sufficiente che il codice sia leggibile da chi effettivamente dovrà lavorare sul codice. Ed è per questo che le code-review sono lo strumento principale per garantire la leggibilità del codice.

Infine c’è da dire che il codice non è scritto nella pietra. La ricerca della miglior leggibilità del codice è un processo continuo. Ogni volta che puoi migliorare la leggibilità è bene non indugiare e farlo subito in modo da ridurre il debito tecnico. Grazie alla suite di test automatici (che non a caso ho inserito tra i requisiti per un buon codice leggibile) potrai rifattorizzare il codice avendo la certezza di non aver rotto nulla.

Fonte
Fonte

Software engineer presso Slope.
Appassionato di videogame, nel tempo libero mi diletto a scrivere su questo blog.
Per non perderti nemmeno un post puoi seguirmi su Telegram!

Cos’è il debito tecnico?

Debito tecnico

Fin da quando ho iniziato a lavorare ho sentito parlare di “debito tecnico”. Al lavoro recentemente abbiamo anche creato una board dedicata esclusivamente al tracciamento del debito tecnico.

Ma che cos’è il debito tecnico? Pur non avendo mai approfondito il concetto è facile capire a grandi linee di cosa si tratta: sono tutte quelle cose che uno lascia indietro oggi per poter rilasciare prima il software sapendo che prima o poi sarà necessario ritornarci sopra.

In realtà la metafora del debito tecnico è un po’ più articolata di così e oggi ho approfittato di un giorno di ferie per studiare meglio la questione analizzando le parole del leggendario Martin Fowler.

Prima di cominciare mi presento, sono Lorenzo Millucci e sono un ingegnere del software che ama lavorare con Symfony e a cui piace condividere in questo blog le cose che impara. Iscriviti al mio canale Telegram per non perderti nessuna notizia!

Definizione

Il debito tecnico è una metafora concepita da Ward Cunningham che assimila la complessità di un software ad un debito finanziario e lo sforzo necessario ad aggiungere una nuova funzionalità all’interesse pagato sul debito.

Ogni riga di codice scritta, ogni libreria installata nel progetto incrementa il livello di complessità generale al progetto andando ad incrementare il debito tecnico.

Esattamente come accade per i debiti finanziari, la scelta migliore è pagare gradualmente in “comode” rate mensili.

La forza di questa metafora consiste nel rendere evidente anche a chi non è un ingegnere del software come anche le attività di refactoring del codice, pur non portando nuove funzionalità al progetto, sono necessarie a “ripagare” la quota del debito.

Ogni volta che è necessario aggiungere una nuova funzionalità al progetto sarebbe buona norma investire del tempo per ristrutturare il codice esistente. Chiaramente in questo modo si otterrebbero dei cicli di sviluppo più lunghi. Tuttavia, qualora dovesse capitare di lavorare nuovamente sulla stessa porzione di codice il lavoro potrebbe procedere in modo molto più spedito avendo già pagato la quota di debito.

Se invece si decidesse di non pagare periodicamente le quote di debito tecnico si finirebbe per avere cicli di sviluppo molto rapidi all’inizio ma, mano a mano che il debito si accumula, i tempi di sviluppo si estenderebbero sempre di più fino ad arrivare al fatidico momento in cui la complessità del software è così alta che non è più possibile sviluppare nuove funzioni in tempi ragionevoli. Quando si arriva in questa situazione, quello che accade solitamente è che si getta la spugna ed è necessario riscrivere da capo il software.

Posso pagare il debito tecnico in stelline?

Una delle principali differenze con i debiti finanziari invece è che, contrariamente ai debiti finanziari in cui l’interesse da pagare è sul totale, sui debiti tecnici il costo da pagare è dipendente dalla porzione di codice. In un software possono esistere parti di codice da incubo con un debito tecnico altissimo ma che non tocca nessuno e quindi un interesse bassissimo e parti di codice che invece sono modificate frequentemente e che quindi pur avendo dei piccoli debiti hanno degli interessi stellari.

TIPOLOGIE DI DEBITO

A seconda di come si affronta il debito tecnico è possibile individuare due classificazioni del debito. Una basata sul rischio (prudente/imprudente) e una basata sulla coscienziosità con cui si protrae il debito (volontario/involontario). Vediamo di seguito come si combinano le due classi:

  • DEBITO VOLONTARIO E PRUDENTE: nello sviluppo di un progetto è ammissibile accettare di fare del debito per concentrarsi sulle cose urgenti. L’importante è sapere che il debito fatto oggi tornerà a chiederci gli interessi domani.
  • DEBITO VOLONTARIO E IMPRUDENTE: questo forse è il caso peggiore. So di indebitarmi pur di consegnare il software ma faccio finta che stia andando tutto bene trascurando completamente le conseguenze di tale indebitamento.
  • DEBITO INVOLONTARIO E IMPRUDENTE: questo in genere accade agli sviluppatori alle prime armi che non conoscono il concetto di debito tecnico e non si rendono conto che cattive scelte fatte in fase di progetto li perseguiteranno in futuro.
  • DEBITO INVOLONTARIO E PRUDENTE: Molto spesso accade che nonostante si abbiano seguito perfettamente le migliori best-practices ci si rende conto che se si fosse utilizzato quel design pattern o quell’altra architettura il codice sarebbe stato sicuramente migliore (in termini di complessità).

Queste combinazioni possono essere riportate in un grafico fatto nel seguente modo:

Il quadrante del debito tecnico

Il fatto che ogni progetto finisca per avere del debito tecnico però non deve essere preso come scusa per trascurare la qualità del codice. Aggiungere codice di scarsa qualità ad un progetto già indebitato fino al collo o scordarsi di pagare le rate degli interessi non può che peggiorare la situazione arrivando a rendere impossibile lo sviluppo di nuove funzionalità.

D’altro canto, un debito ben ragionato con piccole quote di interesse pagate regolarmente può permettere di accelerare il rilascio di nuove funzionalità.

Conclusioni

Ogni volta che adottiamo una soluzione “quick and dirty” per risolvere un problema stiamo facendo debito. Ogni volta che trascuriamo di aggiornare le libreria del progetto stiamo facendo debito. Ogni volta che ci rendiamo conto che avremmo potuto semplificare il codice e non lo facciamo stiamo facendo debito.

Il debito tecnico quindi è un’ombra che che incombe su ogni sviluppatore. Può sembrare minacciosa ma il solo sapere che esiste può essere sufficiente per tenerla a bada. 

Il debito tecnico di per sé non è malvagio. Avere un debito è normale per qualunque azienda si occupi di software. La cosa fondamentale da fare però è fare in modo che non raggiunga mai soglie troppo elevate e che le quote di interesse non schizzino alle stelle paralizzando completamente il progetto. 

Come per i debiti finanziari la bravura sta nel ripagare il debito in piccole rate includendo sempre nella roadmap dei progetti del tempo da dedicare al refactoring del codice.

Fonte
Fonte

Software engineer presso Slope.
Appassionato di videogame, nel tempo libero mi diletto a scrivere su questo blog.
Per non perderti nemmeno un post puoi seguirmi su Telegram!

Firefox disattivare la comparsa della barra dei menù quando si preme alt

Io sono un’amante delle scorciatoie da tastiera, quando posso cerco sempre di utilizzarle al posto del mouse. Utilizzando Firefox su Ubuntu però mi sono accorto di un fastidioso effetto collaterale quando premo il tasto alt (ad esempio quando premo alt + tab per cambiare applicazione aperta).

In pratica quello che succede è che nel momento in cui si preme il tasto alt della tastiera Firefox mostra la barra dei menù (che di solito è nascosta) facendo scorrere di qualche pixel la pagina. Questo, oltre ad essere fastidioso e brutto a vedersi, a volte cattura combinazioni di tasti non desiderate abilitando comportamenti “strani” del browser.

Il fastidioso “balletto” della pagina quando si preme il tasto alt

Intanto mi presento, io sono Lorenzo Millucci e sono un software engineer che ama lavorare con Symfony e a cui piace condividere in questo blog le cose che impara. Iscriviti al mio canale Telegram per non perderti nessuna notizia!

Ma ora torniamo sul pezzo e vediamo subito come risolvere il problema utilizzando due differenti modi.

Modifica della configurazione di Firefox (migliore)

Questo, secondo me, è il metodo migliore da seguire per risolvere il problema alla radice andando a modificare la configurazione interna di Firefox.

La prima cosa da fare è digitare about:config nella barra degli indirizzi di Firefox. Si aprirà una pagina in cui Firefox ti avverte dei rischi collegati alle modifiche che è possibile fare dal pannello delle impostazioni avanzate. Per proseguire bisogna premere il pulsante Accetta il rischio e continua.

A questo punto nella barra in alto bisogna inserire la chiave di ricerca ui.key.menuAccessKeyFocuses e cambiare l’impostazione da true a false.

E il gioco è fatto, d’ora in poi non sarà più visualizzata la barra dei menù quando viene premuto il tasto alt.

Modifica al registro di Firefox per modificare il comportamento del tasto alt
Modifica alla configurazione di Firefox

Rendere sempre visibile la barra dei menù

Questo metodo non richiede di entrare nel pannello delle configurazioni avanzate del browser ma si basa sul rendere sempre visibile la barra dei menù grazie alle infinite possibilità di personalizzazione di Firefox. Tuttavia a parer mio, mostrare sempre una barra che occupa spazio verticale su un monitor 16:9 è proprio uno spreco di spazio per cui preferisco il metodo descritto prima.

Per rendere sempre visibile la barra dei menù devi:

  • premere il bottone con l’icona a forma di hamburger (sarebbe quello con le tre linee orizzontali in alto a destra),
  • clickare sulla voce personalizza
  • selezionare barre degli strumenti e mettere la spunta a barre dei menù
Visualizzare sempre la barra dei menù

Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!

FONTE

Software engineer presso Slope.
Appassionato di videogame, nel tempo libero mi diletto a scrivere su questo blog.
Per non perderti nemmeno un post puoi seguirmi su Telegram!