Quando sono stato introdotto a GitHub, non avevo idea di cosa fosse o cosa potesse fare. Detto tra noi, ho creato l'account perché mi era stato detto che tutti gli sviluppatori ne dovrebbero avere uno sul quale pubblicare il proprio codice.

Per la maggior parte del tempo da principiante non ho fatto nulla col mio account. Ma poi, grazie alla mia passione per tecnologia, ho iniziato a seguire altri sviluppatori e leggere i loro lavori su GitHub. E ho notato una cosa che avevano in comune: avevano tutti progetti interessanti e contribuivano a progetti open source, ma i loro progetti avevano anche dei file README dettagliati.

Quindi il mio interesse in cosa fosse un README era cresciuto, e ho deciso di provare ad aggiungerne uno ai miei progetti. Non mentirò - l'ho fatto di corsa senza alcuna idea su come dovesse essere fatto. E onestamente il risultato non era granché. Guarda tu stesso.

Ed è rimasto così per un periodo di tempo. Ma grazie alla pratica e all'apprendimento continuo ho imparato a realizzare migliori documentazioni come QUESTA, il che ha migliorato la partecipazione con i progetti e ha aiutato altri sviluppatori a unirsi.

É anche importante sapere che un buon README ti aiuterà a farti notare in mezzo alla moltitudine di sviluppatori che pubblicano il loro lavoro su GitHub.

In questo articolo, impareremo cos'é un file README e come scriverne uno. Prima di tutto capiamo cosa si intende per "file README".

Cos'é un file README?

In parole povere, possiamo definire un file README come una guida che dà a un utente una descrizione dettagliata di un progetto sul quale hai lavorato.

Può essere anche descritto come una documentazione con linee guida su come usare un progetto. Di solito contiene istruzioni su come installare ed eseguire un progetto.

É essenziale per te come sviluppatore sapere come documentare il tuo progetto scrivendo un README perché:

• É il primo file che una persona vedrà aprendo il tuo progetto, quindi dovrebbe essere piuttosto sintetico ma dettagliato.
• Farà spiccare il tuo progetto tra gli altri. Ma assicurati che il progetto sia buono.
• Ti aiuterà a definire cosa deve offrire il tuo progetto e come.
• Migliorerà le tue abilità di scrittura, come disse Friedrich Nietzsche:

Un bravo scrittore non possiede solamente il suo spirito, ma anche lo spirito dei suoi amici.

Mentre lavori a un progetto, tieni a mente che dovrai far capire cosa fa il tuo codice anche ad altri sviluppatori. Quindi affiancargli una guida sarà decisamente utile.

Ad esempio, il mio primo progetto mostrato in precedenza, non ha un buon README. E anche se il progetto era fantastico, sarebbe stato difficile per un principiante capire esattamente cosa aspettarsi quando avrebbero clonato il mio repo. Per lui sarebbe anche potuto essere un virus.

Con un progetto del genere su GitHub, non importa quanto sia ben fatto, gli altri sviluppatori non saranno disposti a capirlo e a lavorarci senza un buon README.

Ora, dai un'occhiata a questo progetto. Qui, sei in grado di capire cosa fa il progetto, cosa prevede e come iniziare se hai bisogno di usare o contribuire al progetto.

Vedi, ecco quanto può essere utile un README ben strutturato e come può cambiare il tuo progetto.

Quindi, iniziamo a vedere come puoi scriverne uno.

Come scrivere un buon README - una guida passo passo

Una cosa importante da sapere è che non c'è un modo migliore per strutturare un buon README. Ma c'è un modo sbagliatissimo, ed è non scriverlo affatto.

Studiando vari file README, naturalmente ho delle buone pratiche. E sono proprio queste che condividerò. Come dico sempre:

Ogni giorno è un giorno in cui imparare.

Quindi andando avanti e progredendo nella tua carriera, svilupperai le tue idee su cosa rende ben strutturato un README e come migliorarlo. Magari un giorno scriverai una tua guida originale.

Prima di iniziare, è anche importante sapere che, quando scrivi il tuo README, dovresti essere in grado di rispondere al cosa, al perché, e al come del progetto.

Ecco qualche domanda che ti aiuterà:

• Qual è la tua motivazione?
• Perché hai creato questo progetto?
• Quale problema risolve?
• Cosa hai imparato?
• Cosa lo differenzia dagli altri?
  Se il tuo progetto ha molte funzionalità, considera l'aggiunta di una sezione "Features" nella quale elencarle.

Cosa includere nel tuo README

1. Titolo del progetto

Questo è il nome del progetto. Descrive tutto il progetto in una frase e aiuta le persone a capire qual è l'obiettivo, ovvero a cosa punta il progetto.

2. Descrizione del progetto

Questa è una componente importante del progetto che molti sviluppatori inesperti tendono a sottovalutare.

La descrizione è un aspetto estremamente importante del tuo progetto. Una descrizione ben fatta ti permette di mostrare il tuo lavoro ad altri sviluppatori e a potenziali datori di lavoro.

La qualità di un buona descrizione è spesso la differenza tra un buon progetto ed un progetto carente. Uno buon README sfrutta la possibilità per spiegare e mostrare:

• Cosa fa la tua applicazione,
• Perché hai utilizzato determinate tecnologie,
• Alcune delle difficoltà che hai affrontato e le funzionalità che speri di aggiungere in futuro.

3. Indice (facoltativo)

Se il tuo README è molto lungo, forse è il caso di aggiungere un indice per rendere più semplice la navigazione tra le sezioni.

4. Come installare ed eseguire il progetto

Se stai lavorando su un progetto che l'utente deve installare o eseguire in locale in una macchina come un "POS", dovresti includere i passaggi per installare il tuo progetto ed anche le dipendenze, se ci sono.

Metti a disposizione una descrizione passo passo di come creare ed eseguire l'ambiente di sviluppo.

5. Come usare il progetto

Fornisci istruzioni ed esempi a utenti e collaboratori. Semplificherà loro la vita quando avranno un problema - avranno sempre un posto dove trovare cosa aspettarsi.

Puoi anche usare supporti visivi includendo materiale come screenshot per mostrare esempi del progetto in esecuzione o per mostrare la struttura e i principi di design usati nel tuo progetto.

Se il tuo progetto richiede autenticazioni come password e username, questa è una buona sezione nella quale includere le credenziali.

6. Includi i ringraziamenti/riferimenti

Se hai lavorato su un progetto con un team o un'organizzazione, elenca i tuoi collaboratori/compagni di squadra. Dovresti anche includere un link al loro profilo GitHub e/o ai loro social media.

Inoltre, se hai seguito tutorial o fatto riferimento ad alcuni materiali che potrebbero aiutare l'utente a costruire un particolare progetto, includi i link.

Questo è uno dei modi ringraziare ed aiutare gli altri a mettere mano su progetti simili.

7. Aggiungi una licenza

Per la maggior parte dei file README, questo è solitamente considerata la parte finale. Permette agli altri sviluppatori di sapere cosa possono e non possono fare con il tuo progetto.

Esistono tipi di licenza diversi a seconda del tipo di progetto sul quale stai lavorando. A seconda di quella che sceglierai riceverai diversi tipi di contributi.

La più comune è la Licenza GPL che permette agli altri di modificare il tuo codice ed usarlo a scopi commerciali. Se hai bisogno di aiuto nello scegliere una licenza, dai un'occhiata a questo sito: https://choosealicense.com/ (risorsa in lingua originale inglese).

Fino a questo punto abbiamo soddisfatto i requisiti minimi per un buon README. Ma potresti anche voler considerare di aggiungere le seguenti sezioni per renderlo più interattivo e accattivante.

Sezioni README aggiuntive

8. Badge

I badge non sono necessari, ma usarli è un modo semplice di far sapere agli altri sviluppatori che sai cosa stai facendo.

Avere questa sezione potrebbe anche essere utile per aiutare a linkare i tool più importanti e mostrare qualche statistica riguardante il tuo progetto come il numero di fork, collaboratori, issue aperte ecc.

Ecco uno screenshot di uno dei miei progetti che mostra come poter utilizzare i badge:

Un lato positivo di questa sezione è che si aggiorna automaticamente.

Non sai da dove iniziare? Dai un'occhiata ai badge di shields.io. Hanno un sacco di badge che possono aiutarti a iniziare. Potresti non capirli tutti, ma piano piano inizierai a riuscirci.

9. Come contribuire al progetto

Questo sarà utile soprattutto se stai sviluppando un progetto open-source nel quale avrai bisogno del contributo di altri sviluppatori. Dovrai aggiungere delle linee guida per far sapere loro come contribuire al tuo progetto.

É importante anche assicurarsi che la licenza che scegli per un progetto open-source sia corretta per evitare conflitti futuri. E l'aggiunta di linee guida ai contributi giocherà un ruolo importante.

Alcune delle linee guida più comuni includono il codice di comportamento del collaboratore e la guida alla contribuzione. Queste documentazioni ti daranno il supporto che ti serve quando imposterai le regole del tuo progetto.

10. Includi i test

Vai oltre e scrivi dei test per la tua applicazione. Dopodiché, fornisci esempi di codice e il modo per eseguirli.

Questo aiuterà a mostrare che sei certo e convinto che il tuo codice funzionerà senza difficoltà, il che darà fiducia anche agli altri.

Punti extra

Ecco un altro paio di punti dei quali tenere conto mentre scrivi il tuo README:

• Mantienilo aggiornato - è una buona pratica assicurarsi che il tuo file sia aggiornato. In caso ci fossero modifiche assicurati di aggiornare il README se necessario.
• Scegli una lingua - Veniamo tutti da diversi luoghi e parliamo lingue diverse. Ma questo non significa che tu debba tradurre il tuo codice in dialetto. Scrivere il tuo codice in inglese basta e avanza. Potresti aggiungere un sistema di traduzione in caso la tua audience non conoscesse l'inglese.

Conclusione

Ecco tutto ciò di cui hai bisogno per migliorare i tuoi file README, o addirittura iniziare a scrivere il primo.

A questo punto sono sicuro che tu sia nella posizione di aggiungere una guida interattiva ed informativa al tuo prossimo progetto o a uno già esistente in modo da farlo spiccare.

Ci sono molti strumenti che puoi usare per generare automaticamente un README, ma sarebbe meglio provare a farne qualcuno per conto tuo prima di passare ad automatizzare il processo. Nel caso volessi provarne qualcuno:

• Make a README
• README Generator
• README

Grazie per essere arrivato fino a qui. Se ti è piaciuto questo articolo, per favore condividilo in modo da aiutare altri sviluppatori a migliorare i loro progetti.

Mi piacerebbe vedere il tuo file README appena realizzato. Condividi il link attraverso uno dei seguenti canali:

Connettiti con me: Twitter | YouTube | LinkedIn | GitHub

Condividi la tua opinione, apprezzo i feedback costruttivi!

Buona programmazione ❤

I princìpi SOLID sono cinque principi della progettazione di classi orientate agli oggetti. Sono una serie di regole e buone prassi da seguire mentre si progetta la struttura di una classe.

Questi cinque princìpi ci aiutano a capire la necessità di seguire dei modelli di progettazione e architettura del software in generale. Quindi, credo che questo sia un argomento che ogni sviluppatore dovrebbe imparare.

Questo articolo ti insegnerà tutto ciò di cui hai bisogno per applicare ai tuoi progetti i principi SOLID.

Inizieremo dando un'occhiata alla storia di questo termine. Dopodiché andremo ad approfondire i dettagli più importanti - i perché ed i come di ogni principio - progettando una classe e migliorandola passo dopo passo.

Ora prendi una tazza di caffe o tè e iniziamo!

Contesto

I princìpi SOLID sono stati introdotti dal famoso informatico Robert J. Martin (o Uncle Bob) in un suo articolo del 2000. Ma l'acronimo SOLID venne introdotto successivamente da Michael Feathers.

Uncle Bob è anche l'autore dei bestseller Clean Code e Clean Architecture, ed è uno dei membri della "Alleanza Agile".

Quindi, non è una sorpresa che tutti questi concetti di pulizia del codice, architettura orientata agli oggetti e modelli di progettazione siano in qualche modo connessi e complementari tra loro.

Hanno tutti lo stesso scopo:

"Creare codice comprensibile, leggibile e testabile sul quale molti sviluppatori possano lavorare collaborativamente."

Vediamo i principi uno ad uno. Seguendo l'acronimo SOLID, sono:

• The Single Responsibility Principle - Il principio di singola responsabilità
• The Open-Closed Principle - Il principio aperto/chiuso
• The Liskov Substitution Principle - Il principio di sostituzione di Liskov
• The Interface Segregation Principle - Il principio di segregazione delle interfacce
• The Dependency Inversion Principle - Il principio di inversione delle dipendenze

Il principio di singola responsabilità (SRP)

Il principio di singola responsabilità stabilisce che una classe deve fare solo una cosa e quindi avere un solo motivo per cambiare.

Per chiarire questo principio in modo più tecnico: le specifiche della classe dovrebbero essere influenzate da una sola potenziale modifica (logica del database, logica d'accesso, e così via.) nelle specifiche del software.

Questo significa che se una classe è un contenitore di dati, come una classe Libro o una classe Studente, e ha alcuni campi riguardanti tale entità, questa deve cambiare solo quando cambiamo quel modello di dati.

Seguire il principio di singola responsabilità è importante. Prima di tutto, molti team differenti possono lavorare sullo stesso progetto e modificare le stesse classi per motivi diversi, e ciò potrebbe portare a moduli incompatibili.

Secondo, rende il controllo delle versioni più semplice. Per esempio, ipotizziamo di avere una classe di persistenza che gestisce le operazioni sul database, e vediamo una modifica apportata su quel file dai commit di GitHub. Seguendo l'SRP, sapremo che il file è inerente alla memorizzazione o gestione del database.

I conflitti di merge sono un altro esempio. Appaiono quando team diversi modificano lo stesso file. Ma se l'SRP viene seguito, ci saranno meno conflitti - i file avranno solo un motivo di essere modificati, e i conflitti che esisteranno saranno più semplici da risolvere.

Errori comuni e anti-pattern

In questa sezione, vedremo alcuni errori comuni che violano il principio di responsabilità singola. Poi vedremo come correggere il codice.

Daremo un'occhiata al codice di un semplice programma di fatturazione di una libreria. Iniziamo definendo la classe Libro.

class Libro {
    String nome;
    String nomeAutore;
    int anno;
    int prezzo;
    String isbn;

    public Libro(String nome, String nomeAutore, int anno, int prezzo, String isbn) {
        this.nome = nome;
        this.nomeAutore = nomeAutore;
        this.anno = anno;
        this.prezzo = prezzo;
        this.isbn = isbn;
    }
}

Questa è una semplice classe Libro con qualche campo, nulla di che. Non sto rendendo i campi privati in modo da non dover avere a che fare con getter e setter e concentrarmi più sulla logica.

Ora creiamo la classe di fatturazione che conterrà la logica di creazione della ricevuta e del calcolo del prezzo totale. Per ora, ipotizziamo che la nostra libreria venda solo libri e null'altro.

public class Ricevuta {

	private Libro libro;
	private int quantita;
	private double scontoPercentuale;
	private double tassaPercentuale;
	private double totale;

	public Invoice(Libro libro, int quantita, double scontoPercentuale, double tassaPercentuale) {
		this.libro = libro;
		this.quantita = quantita;
		this.scontoPercentuale = scontoPercentuale;
		this.tassaPercentuale = tassaPercentuale;
		this.totale = this.calcolaTotale();
	}

	public double calcolaTotale() {
	        double prezzo = ((libro.prezzo - libro.prezzo * scontoPercentuale) * this.quantita);

		double prezzoConTasse = prezzo * (1 + tassaPercentuale);

		return prezzoConTasse;
	}

	public void stampaRicevuta() {
            System.out.println(quantita + "x " + libro.nome + " " +          libro.prezzo + "€");
            System.out.println("Percentuale di sconto: " + scontoPercentuale);
            System.out.println("Percentuale di tasse: " + tassaPercentuale);
            System.out.println("Totale: " + totale);
	}

        public void salvaNelFile(String nomefile) {
	// Crea un file con il nome fornito e scrive la ricevuta
	}

}

Ed ecco la classe di fatturazione. Contiene anche alcuni campi riguardanti la ricevuta e 3 metodi:

• Metodo calcolaTotale, che calcola il prezzo totale,
• Metodo stampaRicevuta, che stampa la ricevuta sulla console,
• Metodo salvaNelFile, che scrive la ricevuta su un file.

Prenditi un attimo per pensare a cosa è sbagliato nel modello di questa classe prima di passare al prossimo paragrafo.

Ok, quindi qual è il problema? La nostra classe infrange il principio di singola responsabilità in diversi modi.

La prima violazione è il metodo stampaRicevuta, che contiene la nostra logica di stampa. L'SRP afferma che la nostra classe dovrebbe avere un solo motivo per cambiare, e in questo caso quella ragione dovrebbe essere il calcolo della ricevuta.

Ma con questa architettura, se volessimo cambiare il formato di stampa, avremmo bisogno di modificare la classe. Ecco perché non dovremmo mischiare la logica di stampa con la logica di business nella stessa classe.

C'è anche un altro metodo che viola l'SRP nella nostra classe: il metodo salvaNelFile. Mischiare la logica di persistenza dei dati e la logica di business è un errore estremamente comune.

Non pensare solo alla scrittura su file - potrebbe essere il salvataggio in un database, fare una chiamata a un'API, o altre cose legate alla persistenza dei dati.

Quindi ti chiederai come possiamo sistemare questa funzione di stampa.

Possiamo creare nuove classi per la nostra logica di stampa e di persistenza dei dati, in modo da non dover più modificare la classe di fatturazione per quegli scopi.

Creiamo 2 classi, StampaFattura e MemorizzaFattura, e spostiamo i metodi.

public class stampaFattura {
    private Fattura fattura;

    public stampaFattura(Fattura fattura) {
        this.fattura = fattura;
    }

    public void print() {
        System.out.println(fattura.quantita + "x " + fattura.libro.nome + " " + fattura.libro.prezzo + " €");
        System.out.println("Percentuale di sconto: " + fattura.scontoPercentuale);
        System.out.println("Percentuale di tasse: " + fattura.tassaPercentuale);
        System.out.println("Totale: " + fattura.totale + " €");
    }
}

public class MemorizzaFattura {
    Fattura fattura;

    public MemorizzaFattura(Fattura fattura) {
        this.fattura = fattura;
    }

    public void salvaNelFile(String nomefile) {
        // Crea un file con il nome fornito e scrive la ricevuta
    }
}

Ora la struttura della nostra classe rispetta il principio di responsabilità singola e ogni classe è responsabile di una sola porzione della nostra applicazione. Grandioso!

Il principio aperto/chiuso (OCP)

Il principio aperto/chiuso stabilisce che le classi debbano essere aperte alle estensioni e chiuse alle modifiche.

Per modifica si intende il cambiamento del codice di una classe esistente, ed estensione significa aggiungere nuove funzionalità.

Questo principio sta a significare che dovremmo essere in grado di aggiungere nuove funzionalità senza toccare il codice attuale della classe. Questo perché ogni volta che modifichiamo il codice, rischiamo di dare vita a potenziali bug. Quindi dovremmo evitare di toccare un codice di produzione testato e affidabile dove possibile.

Potresti chiederti come fare ad aggiungere nuove funzionalità senza modificare la classe. Di solito, questo avviene con l'aiuto di interfacce e classi astratte.

Ora che abbiamo coperto le basi del principio, applichiamolo alla nostra applicazione di fatturazione.

Ipotizziamo che il nostro capo sia venuto da noi chiedendoci di salvare le fatture su un database, in modo che possano essere ricercate facilmente. Pensiamo: ok, facilissimo capo, dammi un secondo!

Creiamo il database, ci connettiamo e aggiungiamo un metodo di salvataggio alla nostra classe MemorizzaFattura:

public class MemorizzaFattura {
    Fattura fattura;

    public MemorizzaFattura(Fattura fattura) {
        this.fattura = fattura;
    }

    public void salvaNelFile(String nomefile) {
        // Crea un file con il nome fornito e scrive la ricevuta
    }

    public void salvaNelDatabase() {
        // Salva la fattura nel database
    }
}

Sfortunatamente, proprio come lo sviluppatore pigro della libreria, non abbiamo costruito la classe in modo che sia facilmente estendibile nel futuro. Quindi per aggiungere questa funzionalità, abbiamo modificato la classe MemorizzaFattura.

Se il modello della nostra classe seguisse il principio aperto/chiuso non avremmo avuto bisogno di modificare questa classe.

Quindi, come farebbe lo sviluppatore pigro ma intelligente della libreria, notiamo il problema d'architettura e decidiamo di riscrivere il codice per fare in modo che rispetti il principio.

interface MemorizzaFattura {

    public void salva(Fattura fattura);
}

Cambiamo il tipo di MemorizzaFattura in Interfaccia e aggiungiamo il metodo salva. Ogni classe di persistenza implementerà il metodo salva.

public class PersistenzaDatabase implements MemorizzaFattura {

    @Override
    public void salva(Fattura fattura) {
        // Salva sul DB
    }
}

public class PersistenzaFile implements MemorizzaFattura {

    @Override
    public void salva(Fattura fattura) {
        // Salva su file
    }
}

Quindi la struttura della nostra classe appare così:

Ora la nostra logica di persistenza è facilmente estendibile. Se il nostro capo ci chiede di aggiungere un altro database e avere 2 diversi tipi di database come MySQL e MongoDB, possiamo farlo facilmente.

Potresti pensare che potremmo semplicemente creare classi multiple senza interfacce e aggiungere un metodo salva a tutte queste classi.

Ma immaginiamo di voler estendere la nostra app e avere classi di persistenza multiple come MemorizzaFattura, MemorizzaLibro e creiamo la classe GestionePersistenza che gestisce tutte le classi di memorizzazione:

public class GestionePersistenza {
    MemorizzaFattura memorizzaFattura;
    MemorizzaLibro memorizzaLibro;
    
    public GestionePersistenza(MemorizzaFattura memorizzaFattura,
                              MemorizzaLibro memorizzaLibro) {
        this.memorizzaFattura = memorizzaFattura;
        this.memorizzaLibro = memorizzaLibro;
    }
}

Ora possiamo passare qualsiasi classe che implementa l'interfaccia MemorizzaFattura a questa classe con l'aiuto del polimorfismo. Questa è la flessibilità che ci offrono le interfacce.

Il principio di sostituzione di Liskov (LSP)

Il principio di sostituzione di Liskov stabilisce che le sottoclassi debbano essere sostituibili dalle loro classi d'origine.

Questo significa che, data una classe B, sottoclasse di una classe A, dobbiamo essere in grado di passare un oggetto della classe B a qualsiasi metodo che si aspetti un oggetto della classe A, senza che il metodo restituisca un output inatteso.

Questo è il comportamento previsto, perché quando usiamo l'ereditarietà diamo per scontato che la classe figlia erediti tutto quello che ha la superclasse. La classe figlia estende il comportamento senza mai limitarlo.

Quindi, quando una classe non rispetta questo principio, porta ad alcuni sgradevoli bug difficili da identificare.

Il principio di Liskov è facile da capire ma difficile da trovare nel codice. Quindi diamo un'occhiata a un esempio.

class Rettangolo {
	protected int larghezza, altezza;

	public Rettangolo() {
	}

	public Rettangolo(int larghezza, int altezza) {
		this.larghezza = larghezza;
		this.altezza = altezza;
	}

	public int getLarghezza() {
		return larghezza;
	}

	public void setLarghezza(int larghezza) {
		this.larghezza = larghezza;
	}

	public int getAltezza() {
		return altezza;
	}

	public void setAltezza(int altezza) {
		this.altezza = altezza;
	}

	public int getArea() {
		return larghezza * altezza;
	}
}

Abbiamo una semplice classe Rettangolo, e una funzione getArea che restituisce l'area del rettangolo.

Ora decidiamo di creare un'altra classe per i quadrati. Come saprai, il quadrato è solamente un rettangolo con altezza e larghezza uguali.

class Quadrato extends Rettangolo {
	public Quadrato() {}

	public Quadrato(int lato) {
		larghezza = altezza = lato;
	}

	@Override
	public void setLarghezza(int larghezza) {
		super.setLarghezza(larghezza);
		super.setAltezza(larghezza);
	}

	@Override
	public void setAltezza(int altezza) {
		super.setAltezza(altezza);
		super.setLarghezza(altezza);
	}
}

La nostra classe Quadrato estende la classe Rettangolo. Impostiamo l'altezza e la larghezza con lo stesso valore nel costruttore, ma non vogliamo che un utente cambi altezza o larghezza in modo da violare le proprietà del quadrato.

Quindi sovrascriviamo i setter in modo da impostare entrambe le proprietà, ogni volta che ne viene modificata una. Facendo questo violiamo il principio di sostituzione di Liskov.

Creiamo una classe main per effettuare dei test sulla funzione getArea.

class Test {

   static void getAreaTest(Rettangolo r) {
      int larghezza = r.getLarghezza();
      r.setAltezza(10);
      System.out.println("Risultato previsto " + (larghezza * 10) + ", ottenuto " + r.getArea());
   }

   public static void main(String[] args) {
      Rettangolo rc = new Rettangolo(2, 3);
      getAreaTest(rc);

      Rettangolo sq = new Quadrato();
      sq.setLarghezza(5);
      getAreaTest(sq);
   }
}

Il tester del tuo team ha appena creato la funzione di test getAreaTest e ti dice che la tua funzione getArea non ha passato il test per i quadrati.

Nel primo test, creiamo un rettangolo di larghezza 2 ed altezza 3 e chiamiamo getAreaTest. L'output è 20 come previsto, ma le cose vanno male se passiamo un quadrato. Questo perché la chiamata della funzione setAltezza del test sta impostando anche la larghezza, restituendoci un risultato inaspettato.

Il principio di segregazione delle interfacce (ISP)

Segregare significa tenere delle cose separate, e il principio di segregazione delle interfacce si occupa di separare le interfacce.

Il principio stabilisce che avere interfacce specifiche per ogni client è meglio di avere un'interfaccia di uso generico. I client non dovrebbero essere forzati a implementare funzioni di cui non hanno bisogno.

Questo è un principio semplice da capire e applicare, vediamo un esempio.

public interface Parcheggio {

	void parcheggiaAuto();	// Diminuisce parcheggi vuoti di 1
	void esceAuto(); // Aumenta parcheggi vuoti di 1
	void getCapienza();	// Restituisce capienza auto
	double calcolaQuota(Auto auto); // Restituisce il prezzo in base al numero di ore
	void faiPagamento(Auto auto);
}

class Auto {

}

Abbiamo modellato un parcheggio molto semplificato. Questo è un tipo di parcheggio nel quale paghi una quota oraria. Ora immagina di voler implementare un parcheggio gratuito.

public class ParcheggioGratis implements Parcheggio {

	@Override
	public void parcheggiaAuto() {
		
	}

	@Override
	public void esceAuto() {

	}

	@Override
	public void getCapienza() {

	}

	@Override
	public double calcolaQuota(Auto auto) {
		return 0;
	}

	@Override
	public void faiPagamento(Auto auto) {
		throw new Exception("Il parcheggio è libero");
	}
}

Il nostro parcheggio è composto da 2 cose: la logica relativa al parcheggio (auto parcheggia, auto esce, ottieni capienza) e logica relativa al pagamento.

Ma è troppo specifico e a causa di questo, la classe ParcheggioGratis ha dovuto implementare i metodi relativi al pagamento che sono irrilevanti. Quindi separiamo/segreghiamo le interfacce.

Ora abbiamo separato i parcheggi. Con questo nuovo modello, possiamo anche andare oltre e dividere ParcheggioPagamento per supportare diverse modalità di pagamento.

Ora il nostro modello è molto più flessibile, estendibile e i client non hanno bisogno di implementare alcuna logica irrilevante visto che forniamo solo funzionalità relative al tipo specifico di parcheggio nelle varie interfacce.

Il principio di inversione delle dipendenze (DIP)

Il principio di inversione delle dipendenze stabilisce che le classi debbano dipendere da interfacce o classi astratte invece che da classi concrete e funzioni.

Nel suo articolo (2000), Uncle Bob riassume il principio così:

"Se l' OCP stabilisce l'obiettivo dell'architettura orientata agli oggetti, il DIP ne stabilisce il meccanismo primario".

Questi due principi sono legati ed abbiamo applicato questo schema mentre stavamo discutendo del principio aperto/chiuso.

Vogliamo che le nostre classi siano aperte all'estensione, quindi abbiamo riorganizzato le dipendenze in modo da dipendere da interfacce invece che da classi concrete. La nostra classe GestionePersistenza dipende da MemorizzaFattura, e non dalle classi che implementano questa interfaccia.

Conclusione

In questo articolo, abbiamo iniziato con la storia dei principi SOLID, per poi tentare di acquisire una chiara comprensione delle ragioni dietro a ogni principio e come implementarli. Abbiamo addirittura riscritto una semplice applicazione di fatturazione per farle rispettare i principi SOLID.

Grazie per aver speso il tuo tempo leggendo l'intero articolo. Spero che i concetti espressi siano chiari.

Ti consiglio di tenere questi principi a mente mentre progetti, scrivi e riscrivi i tuoi codici in modo da avere un codice molto più pulito, estendibile e testabile.

Il miglior modo per imparare un nuovo linguaggio di programmazione è usarlo per realizzare dei progetti.

Ho creato una lista di 25 video tutorial (in lingua inglese) per realizzare progetti in Python per principianti.

Il mio consiglio è di guardare il video, costruire il progetto, dividerlo in sezioni e ricostruirlo a modo tuo. Sperimenta aggiungendo nuove funzionalità o usando metodologie differenti.

In questo modo capirai se avrai veramente appreso i concetti o meno.

Puoi cliccare su un progetto qualsiasi di quelli elencati qui sotto per essere reindirizzato nella relativa sezione dell'articolo.

Se non hai familiarità con le basi di Python, suggerisco di guardare questa guida di freeCodeCamp su Python per principianti. In alternativa, puoi consultare il Manuale Python per principianti (in italiano).

Progetti in Python che puoi realizzare

• Parole matte (Mad Libs) in Python
• Indovina il numero in Python (computer)
• Indovina il numero in Python (utente)
• Sasso, carta, forbice in Python
• L'impiccato in Python
• Conto alla rovescia in Python
• Generatore di password in Python
• Codifica/decodifica di codici QR in Python
• Tris in Python
• Tris con Intelligenza Artificiale in Python
• Ricerca binaria in Python
• Campo minato in Python
• Risolutore di sudoku in Python
• Manipolazione di foto in Python
• Compositore testuale di catene di Markov in Python
• Pong in Python
• Snake in Python
• Forza quattro in Python
• Tetris in Python
• Gioco multigiocatore online in Python
• Web Scraper in Python
• Rinominatore di file in massa in Python
• Programma meteorologico in Python
• Sviluppa un bot di Discord con Python
• Space Invaders in Python

Parole matte (Mad Libs) in Python

In questo video di Kylie Ying, imparerai come ottenere degli input da un utente, lavorare con le f-strings e vedere i risultati sulla console.

Questo progetto è un ottimo punto di partenza per prendere mano con la concatenazione di stringhe in Python.

Indovina il numero (computer) in Python

In questo video di Kylie Ying, imparerai a lavorare con il modulo random di Python, costruire funzioni, usare i loop while e i condizionali, e ottenere degli input da un utente.

Indovina il numero (utente) in Python

In questo video di Kylie Ying, costruirai un indovinello nel quale il computer dovrà indovinare il numero corretto. Lavorerai con il modulo random di Python, costruirai funzioni, lavorerai con i loop while e i condizionali, e otterrai degli input da un utente.

Sasso, carta, forbice in Python

In questo video di Kylie Ying, lavorerai con random.choice(), istruzioni if e otterrai degli input da un utente. Questo è un ottimo progetto per imparare a utilizzare principi fondamentali come condizionali e funzioni.

L'impiccato in Python

In questo video di Kylie Ying, lavorerai con i dizionari, le liste e le istruzioni if annidate. Lavorerai anche con le stringhe e il modulo random di Python.

Conto alla rovescia in Python

In questo video di Code With Tomi, costruirai un conto alla rovescia grazie al modulo time di Python. Questo è un ottimo progetto per familiarizzare con i loop while in Python.

Generatore di password in Python

In questo video di Code With Tomi, costruirai un generatore di password casuale. Otterrai dati dall'utente sul numero di password da generare e la loro lunghezza ed il tuo programma produrrà una collezione di password con caratteri casuali.

Questo progetto ti impratichirà nell'utilizzo dei loop for e del modulo random di Python.

Codifica/decodifica di codici QR in Python

In questo video di Code With Tomi, creerai i tuoi codici QR e codificherai/decodificherai informazioni da essi. Questo progetto utilizza la libreria qrcode.

Questo è un ottimo progetto per prendere familiarità con l'installazione e l'utilizzo di diversi moduli Python.

Tris in Python

In questo video di Kylie Ying, svilupperai un tris a più giocatori su riga di comando. Imparerai a lavorare con i moduli Python time e math e ti eserciterai con le istruzioni if annidate.

Tris con Intelligenza Artificiale in Python

In questo video di Kylie Ying, svilupperai un programma per giocare partite di tris contro un computer che non perde mai. Questo progetto utilizza l'algoritmo minimax, un algoritmo ricorsivo utilizzato per i processi decisionali.

Ricerca binaria in Python

In questo video di Kylie Ying, implementerai l'algoritmo divide et impera chiamato ricerca binaria. È un comune algoritmo di ricerca spesso utilizzato nei colloqui di lavoro, quindi importante da saper implementare.

Campo minato in Python

In questo video di Kylie Ying, svilupperai il classico gioco campo minato su riga di comando. Questo progetto si concentra sulla ricorsività e le classi.

Risolutore di sudoku in Python

In questo video di Kylie Ying, svilupperai un risolutore di Sudoku che utilizza la tecnica backtracking. Il backtracking è una tecnica ricorsiva che cerca ogni possibile combinazione per risolvere un problema.

Manipolazione di foto in Python

In questo video di Kylie Ying, creerai un filtro per immagini e cambierai contrasto, luminosità e sfocatura di immagini. Prima di iniziare il progetto, dovrai scaricare i file di partenza.

Compositore testuale di catene di Markov in Python

In questo video di Kylie Ying, imparerai cos'è il modello grafico della catena di Markov e come può essere applicato alle relazioni tra testi di diverse canzoni. Questo progetto è un'ottima introduzione all'intelligenza artificiale in Python.

Pong in Python

In questo video di Christian Thompson, ricreerai il classico videogioco pong in Python. Lavorerai con i moduli Python  os e turtle, perfetti per creare grafiche di videogiochi.

Snake in Python

In questo video di Tech with Tim, ricreerai il classico videogioco snake in Python. Questo progetto si basa sulla programmazione orientata agli oggetti e Pygame, un popolare modulo Python per lo sviluppo di videogiochi.

Forza quattro in Python

In questo video di Keith Galli, costruirai il classico gioco forza quattro in Python. Questo progetto utilizza i moduli Python numpy, math, pygame e sys.

È un ottimo progetto se hai già sviluppato altri progetti più piccoli in Python. Ma se non hai ancora creato alcun progetto in Python, consiglierei vivamente di iniziare con uno dei progetti citati precedentemente nella lista ed esercitarti un po' prima di tornare su questo.

Tetris in Python

In questo video di Tech with Tim, ricreerai il classico videogioco Tetris. In questo progetto utilizzerai Pygame ed è ottimo per i programmatori principianti che vogliono portare le proprie conoscenze al livello successivo.

Gioco multigiocatore online in Python

In questo video di Tech with Tim, svilupperai un videogioco multiplayer che potrai giocare con chiunque abbia una connessione internet. Questo progetto è un'ottima introduzione a socket, reti e Pygame.

Web Scraper in Python

In questo video di Code With Tomi, imparerai come richiedere come input a un utente un link di un utente GitHub e produrre come output il link dell'immagine del profilo grazie al web scraping. Il web scraping è una tecnica che ti permette di raccogliere dati da una pagina web.

Rinominatore di file in massa in Python

In questo video di Code With Tomi, svilupperai un programma in grado di entrare in qualsiasi cartella del tuo computer e rinominare tutti i file in base a delle condizioni impostate dal tuo codice Python.

Programma meteorologico in Python

In questo video di Code With Tomi, svilupperai un programma in grado di raccogliere dati su una specifica località e produrre dettagli sulle previsioni per la località in questione. Questo è un ottimo progetto per imparare a ottenere dati da delle API.

Sviluppa un bot di Discord con Python

In questo video di Beau Carnes, svilupperai il tuo bot di Discord, una piattaforma dove le persone possono parlare e scriversi online. In questo progetto lavorerai con l'API di Discord e l'ambiente di sviluppo Replit.

Dopo la pubblicazione di questo video, Replit ha cambiato modo di memorizzare le variabili d'ambiente nei tuoi programmi. Leggi questa guida su come immagazzinare le variabili d'ambiente in modo corretto.

Nota: a causa di alcuni aggiornamenti di Discord, occorre fare degli aggiustamenti per far funzionare correttamente il bot.

Space Invaders in Python

In questo video di buildwithpython, svilupperai il classico gioco space invaders usando Pygame. Apprenderai le basi dello sviluppo di videogiochi come loop, rilevamento di collisioni, eventi legati alla pressione dei tasti e altro.