Come usare Git e GitHub: Guida completa per sviluppatori

Ti sei mai trovato a lavorare su un progetto, magari un testo importante o, ancora meglio, il codice della tua prossima app rivoluzionaria, e hai pensato: “Mamma mia, ho fatto un casino! Vorrei poter tornare indietro nel tempo…”? Beh, se la risposta è sì, preparati perché sto per presentarti due strumenti che ti cambieranno la vita (o almeno la vita da sviluppatore): Git e GitHub.

Magari ne hai già sentito parlare, magari ti sembrano concetti un po’ oscuri. Non preoccuparti! Immagina di avere tra le mani una specie di macchina del tempo super potente per i tuoi progetti digitali, unita a una piattaforma social dove puoi mostrare al mondo (o a un team di lavoro) le tue creazioni e collaborare in modo super efficiente. Figo, vero?

Perché dovresti imparare Git e GitHub?

Lascia che ti dia qualche motivo, così, tanto per stuzzicare la tua curiosità:

• Traccia ogni cambiamento: Git registra ogni singola modifica che fai ai tuoi file. Vuoi tornare a una versione precedente? Nessun problema! Hai accidentalmente cancellato qualcosa di importante? Git ti copre le spalle. Pensa a quante volte avresti voluto questa magia nella tua vita!
• Collaborazione senza stress: Se lavori in team (e fidati, quasi sempre sarà così), Git e GitHub rendono la collaborazione un gioco da ragazzi. Più persone possono lavorare sullo stesso progetto contemporaneamente senza pestarsi i piedi. Addio ai file “versione_finale”, “versione_finale_v2”, “versione_finale_definitiva”… ti suona familiare? 
• Backup sicuro e accessibile: I tuoi progetti sono al sicuro su GitHub, un po’ come avere un backup nel cloud sempre a portata di mano. Puoi accedere al tuo codice da qualsiasi computer e condividerlo facilmente.
• Standard del settore: Se vuoi lavorare nel mondo dello sviluppo, conoscere Git e GitHub non è un optional, è un requisito fondamentale. È come sapere l’alfabeto per uno scrittore.
• Mostra il tuo talento: GitHub è anche un portfolio online per i tuoi progetti. Puoi mostrare al mondo cosa sai fare e magari farti notare da potenziali datori di lavoro.

Ok, mi hai convinto! Da dove si comincia?

Ottimo! Iniziamo con il setup iniziale.

1. Installare Git:

La prima cosa da fare è installare Git sul tuo computer. È un software gratuito e open source, quindi non dovrai sborsare un centesimo.

• Su Windows: Vai sul sito ufficiale di Git (git-scm.com) e scarica l’installer. Segui le istruzioni a schermo (di solito basta cliccare “Next” un po’ di volte).
• Su macOS: Se hai un Mac, probabilmente Git è già installato. Puoi verificarlo aprendo il Terminale (lo trovi in Applicazioni > Utility) e digitando git –version. Se non è installato, puoi scaricarlo dal sito ufficiale o usare un gestore di pacchetti come Homebrew (brew install git).
• Su Linux: Apri il tuo terminale e usa il gestore di pacchetti della tua distribuzione (ad esempio, su Debian/Ubuntu usa sudo apt-get install git, su Fedora/CentOS usa sudo yum install git).

2. Configurare Git:

Una volta installato, devi configurare Git con il tuo nome e la tua email. Questi dati verranno associati ai tuoi “commit” (vedremo tra poco cosa sono). Apri il terminale e digita questi comandi, sostituendo “Il Tuo Nome” e “la_tua@email.com” con le tue informazioni:

git config --global user.name "Il Tuo Nome" git config --global user.email "la_tua@email.com"

Questo comando –global fa sì che queste impostazioni vengano applicate a tutti i tuoi progetti Git.

I comandi base: Il vocabolario di Git

Ora che hai Git pronto, impariamo le parole chiave per comunicare con lui.

• git init: Questo è il primo comando che devi dare quando vuoi iniziare a tracciare un nuovo progetto con Git. April il terminale, spostati nella cartella del tuo progetto e digita git init. Questo comando crea una sottocartella nascosta chiamata .git, dove Git memorizzerà tutte le informazioni sulla cronologia del tuo progetto. Pensa a questa cartella come al cuore pulsante della tua macchina del tempo.
  Esempio pratico: Stai creando un sito web. Apri il terminale, vai nella cartella del tuo sito (cd percorso/al/tuo/sito) e digita git init. Ora Git sta “ascoltando” i cambiamenti in questa cartella.
• git add: Dopo aver modificato i tuoi file, devi dire a Git quali modifiche vuoi includere nel tuo prossimo “snapshot” (il commit). Il comando git add serve proprio a questo.

• git add <nome_file>: Aggiunge un singolo file specifico. Ad esempio, git add index.html aggiungerà solo il file index.html.
• git add .: Aggiunge tutti i file modificati e non tracciati nella cartella corrente e nelle sottocartelle. Fai attenzione a non aggiungere file indesiderati!
• git add *: Simile a git add ., ma a volte può avere comportamenti leggermente diversi con file nascosti. Di solito, git add . è la scelta più sicura per aggiungere tutto.

Esempio pratico: Hai modificato index.html e aggiunto un nuovo file chiamato style.css. Per includere entrambi nel prossimo commit, puoi fare:

git add index.html git add style.css 

Oppure, più semplicemente:

git add .

• git commit: Questo è il comando che crea uno “snapshot” del tuo progetto in quel preciso momento. Ogni commit ha un messaggio associato che descrive le modifiche apportate. È fondamentale scrivere messaggi di commit chiari e concisi, così in futuro sarà facile capire cosa è stato fatto in ogni passaggio.
  

  git commit -m "Aggiunta la struttura base del sito web"

  L’opzione -m ti permette di scrivere il messaggio direttamente nel comando. Se la ometti, si aprirà un editor di testo dove potrai scrivere un messaggio più dettagliato.
  Consiglio da amico: Cerca di scrivere messaggi di commit significativi. Invece di “modifiche”, prova a scrivere qualcosa come “Fix: Corretto bug nel modulo di login” o “Feat: Implementata la funzionalità di ricerca”. Ti ringrazierai in futuro!

• git push: Questo comando serve a inviare i tuoi commit a un repository remoto, come ad esempio un repository su GitHub. Ma aspetta, cosa sono i repository remoti? Ci arriviamo tra un attimo! Per ora, sappi che git push è come caricare i tuoi progressi sul cloud.
  Di solito, la prima volta che fai un push, dovrai specificare il nome del repository remoto e il branch (altra parola magica che vedremo dopo). Il comando tipico è:
  

  git push origin main

  Dove origin è il nome convenzionale che si dà al repository remoto principale e main è il nome del branch principale (potrebbe anche essere master a seconda delle impostazioni).

• git pull: Se qualcun altro ha apportato modifiche al repository remoto, o se hai lavorato sul progetto da un altro computer, devi “tirare” (pull) le modifiche locali. Il comando git pull fa proprio questo: scarica le modifiche dal repository remoto e le unisce al tuo repository locale.
  

  git pull origin main

  Anche qui, origin e main si riferiscono al repository remoto e al branch.

Creare un repository GitHub: La tua casa per il codice nel cloud

Ora che hai familiarizzato con i comandi base di Git, è il momento di parlare di GitHub. GitHub è una piattaforma web che ospita repository Git remoti. Pensa a GitHub come a un grande social network per sviluppatori, dove puoi condividere il tuo codice, collaborare con altri e scoprire progetti interessanti.

Come creare un repository su GitHub:

1. Crea un account: Se non ne hai già uno, vai su github.com e crea un account. È gratuito!
2. Crea un nuovo repository: Una volta loggato, clicca sul pulsante “+” in alto a destra e seleziona “New repository”.
3. Dai un nome al tuo repository: Scegli un nome descrittivo per il tuo progetto.
4. Aggiungi una descrizione (opzionale): Puoi aggiungere una breve descrizione per spiegare di cosa tratta il tuo progetto.
5. Scegli se il repository deve essere pubblico o privato:

• Pubblico: Chiunque può vedere il tuo codice. Ottimo per progetti open source o per mostrare il tuo lavoro.
• Privato: Solo le persone che inviti possono vedere il tuo codice. Ideale per progetti aziendali o personali che non vuoi condividere pubblicamente.

1. Inizializza il repository con un README (opzionale): Un file README è una buona pratica per descrivere il tuo progetto. GitHub ti offre la possibilità di crearne uno vuoto all’inizio.
2. Clicca su “Create repository”.

Una volta creato il repository su GitHub, ti verrà fornita una serie di istruzioni per collegare il tuo repository locale (quello che hai inizializzato con git init sul tuo computer) a quello remoto su GitHub. Solitamente, dovrai usare il comando git remote add per “collegare” i due repository:

git remote add origin <URL_del_tuo_repository_GitHub>

Dove <URL_del_tuo_repository_GitHub> è l’indirizzo web del repository che hai appena creato su GitHub (lo trovi nella pagina del repository). origin è semplicemente un nome che dai a questa connessione remota. È una convenzione comune chiamarlo così.

Dopo aver aggiunto il remote, potrai usare git push origin main per inviare il tuo codice a GitHub per la prima volta.

Fork, Branch, Pull Request: Il potere della collaborazione

Ora arriviamo alle funzionalità più avanzate (ma non spaventarti, le spiegheremo in modo semplice!) che rendono Git e GitHub così potenti per la collaborazione.

• Fork: Immagina di trovare un progetto interessante su GitHub a cui vorresti contribuire. Invece di modificare direttamente il progetto originale (cosa che di solito non hai il permesso di fare se non sei un membro del team), puoi creare una “copia” del progetto sul tuo account GitHub. Questa copia si chiama fork. È come prendere una fotocopia di un libro che ti interessa per poterlo sottolineare e annotare senza rovinare l’originale.
  Come fare un fork: Vai sulla pagina del repository GitHub che ti interessa e clicca sul pulsante “Fork” in alto a destra. GitHub creerà una copia del repository nel tuo account.
• Branch: Un branch è come una linea di sviluppo parallela nel tuo progetto. Immagina di avere il ramo principale del tuo progetto (solitamente chiamato main o master) che rappresenta la versione stabile. Quando vuoi aggiungere una nuova funzionalità o correggere un bug, invece di lavorare direttamente sul ramo principale (che potrebbe introdurre instabilità), crei un nuovo branch. Questo ti permette di isolare le tue modifiche e di lavorare su di esse senza influenzare la versione principale. Una volta che le tue modifiche sono pronte e testate, puoi “unire” (merge) il tuo branch di nuovo al ramo principale. Pensa ai branch come a dei binari ferroviari temporanei che si diramano dal binario principale per poi ricongiungersi.
  Comandi utili per i branch:

• git branch: Elenca i branch presenti nel tuo repository locale. Il branch attivo è contrassegnato da un asterisco (*).
• git branch <nome_branch>: Crea un nuovo branch con il nome specificato.
• git checkout <nome_branch>: Passa al branch specificato, rendendolo il branch attivo.
• git checkout -b <nome_branch>: Crea un nuovo branch e ci passa subito. È una scorciatoia per i due comandi precedenti.
• git merge <nome_branch>: Unisce le modifiche dal branch specificato al branch corrente.
• git branch -d <nome_branch>: Elimina il branch specificato (solo se le modifiche sono già state unite).

Esempio pratico: Stai lavorando a una nuova funzionalità per la tua app. Crea un nuovo branch chiamato feature-nuovo-login:

git checkout -b feature-nuovo-login 

Ora lavori su questo branch. Quando hai finito, torni al branch principale (main) e unisci le modifiche:

git checkout main git merge feature-nuovo-login

• Pull Request (PR): Una pull request è il modo in cui proponi le tue modifiche (che hai fatto su un branch) per essere unite al ramo principale di un altro repository (magari il repository originale da cui hai fatto il fork). Immagina di aver fatto delle modifiche fantastiche al libro che hai fotocopiato e ora vuoi suggerire all’autore di includerle nell’edizione ufficiale. La pull request è come inviare una lettera all’autore con le tue proposte di modifica.
  Come creare una pull request:

1. Dopo aver fatto le tue modifiche su un branch del tuo fork e averle pushato sul tuo repository GitHub, vai sulla pagina del repository originale su GitHub.
2. Dovresti vedere un messaggio che ti invita a confrontare e creare una pull request con il tuo branch. Clicca sul pulsante “Compare & pull request”.
3. GitHub ti mostrerà un confronto tra le tue modifiche e il ramo principale del repository originale.
4. Aggiungi un titolo e una descrizione chiara e concisa per la tua pull request, spiegando quali modifiche hai apportato e perché dovrebbero essere unite.
5. Clicca su “Create pull request”.

A questo punto, i manutentori del repository originale potranno vedere la tua pull request, esaminare le tue modifiche, fare commenti o domande e, se tutto va bene, unire il tuo branch al ramo principale del loro progetto.

Esempi di applicazione e un tocco di codice

Ok, finora abbiamo parlato della teoria. Ma come si applica tutto questo nel mondo reale dello sviluppo di un’app?

Immagina di voler creare una semplice app per la gestione delle tue ricette preferite. Potresti iniziare creando un repository GitHub chiamato my-recipe-app.

1. Setup iniziale: Crei la struttura base del progetto (magari con un file README.md per la descrizione e una cartella src per il codice). Fai git init, git add ., e git commit -m “Initial commit: Struttura base del progetto”. Poi colleghi il tuo repository locale a quello remoto su GitHub con git remote add origin <URL> e fai il primo git push origin main.
2. Sviluppo della funzionalità di aggiunta ricette: Crei un nuovo branch chiamato feature-add-recipe (git checkout -b feature-add-recipe). Inizi a scrivere il codice per permettere all’utente di aggiungere nuove ricette. Magari usi Python con il framework Flask per creare una semplice API. Potresti avere un file app.py con codice simile a questo:
   
   

   from flask import Flask, request, jsonify app = Flask(__name__) recipes = [] @app.route('/recipes', methods=['POST']) def add_recipe():     data = request.get_json()     name = data.get('name')     ingredients = data.get('ingredients')     if name and ingredients:         recipe = {'id': len(recipes) + 1, 'name': name, 'ingredients': ingredients}         recipes.append(recipe)         return jsonify(recipe), 201     return jsonify({'error': 'Missing name or ingredients'}), 400 if __name__ == '__main__':     app.run(debug=True)

   Dopo aver scritto il codice, fai git add . e git commit -m “Feat: Implementata la funzionalità per aggiungere ricette”.

3. Sviluppo dell’interfaccia utente: Crei un altro branch chiamato feature-user-interface (git checkout -b feature-user-interface). Magari usi HTML, CSS e JavaScript per creare una semplice interfaccia web per interagire con la tua API. Potresti usare librerie JavaScript come Workspace per fare le chiamate all’API.
   Dopo aver sviluppato l’interfaccia, fai git add . e git commit -m “Feat: Creata l’interfaccia utente per visualizzare e aggiungere ricette”.
4. Unione dei branch: Una volta che le funzionalità sono pronte e testate, torni al branch main (git checkout main) e unisci i branch delle funzionalità: git merge feature-add-recipe e git merge feature-user-interface. Potresti risolvere eventuali conflitti se ci sono modifiche che si sovrappongono.
5. Push su GitHub: Infine, fai git push origin main per inviare tutte le tue modifiche al repository remoto su GitHub.

Se volessi collaborare con un amico a questo progetto, lui potrebbe fare un fork del tuo repository, creare un suo branch per aggiungere una funzionalità (ad esempio, la possibilità di cercare ricette per ingrediente), fare i suoi commit e poi inviarti una pull request per proporti di unire le sue modifiche al tuo progetto.

Consigli pratici:

• Commit spesso e con messaggi chiari: Non aspettare di aver finito un’intera funzionalità per fare un commit. Fai commit piccoli e frequenti, ogni volta che raggiungi un punto significativo. E ricorda, messaggi di commit chiari sono fondamentali!
• Usa i branch per ogni nuova funzionalità o correzione di bug: Questo ti permette di mantenere il tuo ramo principale sempre stabile.
• Fai pull regolarmente: Prima di iniziare a lavorare, fai sempre un git pull per assicurarti di avere l’ultima versione del codice.
• Impara a risolvere i conflitti di merge: A volte, quando unisci due branch, Git potrebbe non essere in grado di capire automaticamente come combinare le modifiche. Imparare a risolvere i conflitti è un’abilità essenziale.
• Leggi la documentazione: La documentazione ufficiale di Git e GitHub è una miniera di informazioni. Non aver paura di consultarla quando hai dei dubbi.
• Esplora GitHub: GitHub è pieno di progetti open source fantastici. Esplora, guarda il codice degli altri, e magari contribuisci anche tu!

Conclusione: Il tuo viaggio nel mondo del controllo di versione è appena iniziato!

Spero che questa guida ti abbia dato una buona base per iniziare a usare Git e GitHub. Ricorda, all’inizio potrebbe sembrare un po’ complicato, ma con la pratica diventerà una seconda natura. Git e GitHub sono strumenti potentissimi che ti apriranno le porte a un mondo di possibilità nella programmazione e nella collaborazione.

Non esitare a sperimentare, a fare errori (tanto c’è Git che ti permette di tornare indietro!), e a cercare risorse online per approfondire ulteriormente. Il mondo dello sviluppo è in continua evoluzione, e imparare a usare strumenti come Git e GitHub è un passo fondamentale per rimanere al passo.

Allora, sei pronto a creare il tuo primo repository e a fare il tuo primo commit? Forza e coraggio, il tuo viaggio nel fantastico mondo del controllo di versione è appena iniziato! E se hai domande, sai dove trovarmi!