Blog

Le convenzioni nella programmazione informatica sono fondamentali per scrivere un codice facilmente comprensibile, ordinato e di qualità.

Non è un caso che costituiscano, dunque, la base per imparare a programmare, poiché senza di esse risulterà molto difficile addentrarsi in maniera approfondita nella sintassi e semantica dei vari linguaggi di programmazione.

Per definizione la naming convention è un insieme di regole per la scelta della sequenza di caratteri da utilizzare per gli identificatori di variabili, tipi, funzioni e tutte le altre entità nel codice sorgente e nella documentazione.

Queste convenzioni rendono il codice leggibile da chiunque. Padroneggiare questo requisito è il primo passo per scrivere codice di qualità. Indipendentemente dal linguaggio di programmazione, adottare una naming convention corretta, renderà il nostro script comprensibile ad una persona che parla una lingua diversa dalla nostra, di un’altra cultura e che pensa in modo diverso dal nostro.

Per questo è importante seguire poche – ma efficaci! – regole per la stesura del codice.

• Consistenza: scegli una parola per sintetizzare un concetto. Mantenere una coerenza nella scrittura del codice è importante per dare senso a quello che si sta scrivendo, ma anche uniformità e sintesi, ad esempio:
   

getName() {…}

retrieveName() {…}

bringBackName() {…}

In questo caso, stiamo definendo un metodo che restituisce il nome di qualcosa. Anche se scritto in tre modi differenti, è facile intuire che i nomi assegnati al metodo svolgono la stessa operazione. Per imparare a programmare è importante essere sintetici in ogni parte del codice che si sta scrivendo.

• Significativo: un codice leggibile, come abbiamo già detto, è in grado di essere compreso da chiunque lo legga. Essere sintetici non vuol dire scrivere parole brevi o utilizzare identificatori poco discorsivi. Si può essere esplicativi scrivendo le parole giuste nel giusto contesto. Utilizzare una naming convention troppo generica potrebbe essere fuorviante per chi leggerà il nostro codice.
   

  const USERS; vs const NUMBER_OF_USERS;
  
  const FRIENDS; vs const NUMBER_OF_FRIENDS;

  Vedi? È chiaro che la nomenclatura adottata nella parte destra è più indicata, specialmente se si stanno dichiarando delle costanti immutabili all’interno del codice!

• Leggibilità: quando si dichiara una variabile o si definisce un metodo, è importante scegliere un termine (o più termini) adeguati a ciò che quell’entità nel codice rispecchia. Dare un nome poco comprensibile non aiuta il codice ad essere auto-esplicativo. Quando si legge una variabile o un metodo deve essere istantanea la comprensione di cosa svolge, o cos’è, quel blocco di codice.

String lblFname; vs String label_first_name;

Utilizzare caratteri in più non ci costa nulla. Adottare una nomenclatura come riportato a sinistra nell’esempio, rende la variabile poco comprensibile e anche difficile da ricercare all’interno dello script se si vuole risalire ad essa.

• Abbreviazioni: come detto in precedenza, essere risoluti e riassuntivi nella stesura del codice è importante per renderlo compatto e comprensibile. Per questo è importante saper abbreviare i nomi che diamo alle entità nel codice. Se dobbiamo assegnare il nome ad un bottone, chiameremo la variabile first_btn anziché first_button e adotteremo questa tecnica per tutti i nomi assegnati all’interno del codice.

•  Tipi di denominazione: negli anni la programmazione informatica ha subito numerose evoluzioni e cambiamenti. Gli sviluppatori e i programmatori hanno definito delle vere e proprie convenzioni (Case-Notation) da adottare per le entità all’interno del codice. Queste sono:

1. Camel Case: in questa notazione si inizia a scrivere il nome dell’entità con la lettera minuscola, se però l’entità è composta da più parole, le successive inizieranno con la lettera maiuscola:

   firstName oppure countStudents(). 

   Questa è una delle notazioni più diffuse tra i linguaggi di programmazione, utilizzata nel linguaggio Java, nel linguaggio PHP, nel linguaggio C# e in gran parte dei linguaggi object-oriented.

2. Snake Case: come il già citato Camel Case, si parte con la lettera minuscola, ma se ci sono più parole che danno il nome all’entità, le successive saranno precedute da un trattino basso:

   first_name oppure compute_mean().

    Questa notazione è più facile trovarla in C++, Perl,  nel linguaggio Python o R. Insieme alla notazione citata in precedenza, risulta essere una delle più utilizzate nel mondo della programmazione informatica.

3. Pascal Case: si differenzia dai precedenti perché la prima lettera è già maiuscola. Qualsiasi sia l’entità da definire, la prima lettera sarà sempre maiuscola:

   FirstName, ReverseName().

    Utilizzato anche questo spesso e volentieri per i linguaggi di programmazione orientati ad oggetti, mai utilizzato invece per il linguaggio Python, C o per il linguaggio JavaScript.

4. Kebab Case: si tratta della notazione meno utilizzata all’interno dei linguaggi di programmazione. Prevede la presenza di un trattino, tra la prima parola e le successive, anziché del trattino basso come visto nella Snake Case: 

   first-name oppure compute-mean().

    

• Aggiungere metadati allo script: imparare a programmare vuol dire saper rendere il codice illustrativo, in quello che si sta realizzando. Fornire informazioni aggiuntive è considerato un plus per chi scrive codice di qualità. Questo può avvenire quando si riesce ad inserire metadati nei nomi che si forniscono alle entità del codice. (Ad esempio, far capire attraverso il nome di un metodo che svolge attività complesse o quali).

Ognuno ha il suo modo di scrivere il codice, ma è cruciale rispettare queste caratteristiche per avere uno script leggibile. Inoltre, andando sempre più in profondità vedremo che ogni linguaggio di programmazione ha le sue convenzioni. Ad esempio, nel linguaggio Java le classi e le interfacce devono iniziare con la maiuscola, mentre i metodi e le variabili con la lettera minuscola. Nel linguaggio Python non è questo lo standard e in C le convenzioni cambiano nuovamente.

Ricorda! Non rispettare determinate regole e convenzioni rischia di compromettere l’integrità del codice, rendendolo difficile da comprendere addirittura per chi lo scrive.