Apèndix E — Git, GitHub i GitHub Classroom

Objectius

  • Entendre què és un control de versions i per què és imprescindible.
  • Fer servir els comandaments bàsics de Git: init, add, commit, status, log.
  • Treballar amb un repositori remot a GitHub: clone, push, pull.
  • Escriure un .gitignore adequat per a projectes Java.
  • Seguir el flux de GitHub Classroom per acceptar i lliurar activitats del curs.

Durant el curs faràs molts exercicis i pràctiques. Necessites una manera fiable de guardar-ne l’historial, no perdre feina i entregar-la. al professorat. Aquesta eina és Git, i el lloc on desaràs el codi a Internet és GitHub.

E.1 Què és un control de versions?

Un sistema de control de versions és un programa que guarda l’historial dels canvis d’un projecte.

Cada cop que fas una “foto” del teu codi, la pots recuperar més endavant, veure què has canviat i tornar enrere si t’equivoques.

ConsellAnalogia: les partides d’un videojoc

Git és com desar la partida en un videojoc. Vas jugant (programant) i, en moments clau, graves.

Si més endavant t’eliminen (trenques el codi), pots carregar l’última partida que funcionava. Sense guardar, hauries de començar de zero.

Sense control de versions, la gent acaba amb carpetes com projecte_final, projecte_final_BO, projecte_final_BO_de_veritat. Git elimina aquest caos: una sola carpeta, amb tot l’historial a dins.

Git és el programa que s’executa al teu ordinador (local). GitHub és un servei web on pots publicar els teus repositoris Git perquè estiguin segurs al núvol i els puguis compartir. No són el mateix: Git funciona sense Internet; GitHub és el lloc on el penges.

E.2 Instal·lació i configuració inicial

Descarrega Git de git-scm.com i instal·la’l. La primera vegada, digues-li qui ets. Aquesta informació quedarà registrada en cada canvi fet.

git config --global user.name "El teu nom"
git config --global user.email "adreca@exemple.cat"

git --version   # Comprova que ha anat bé

E.3 Les comandes de Git

El cicle de treball diari de Git té molt poques ordres. Aquest és el nucli:

flowchart LR
    A["Directori de treball<br/>(edites fitxers)"] -->|git add| B["Zona d'espera<br/>(staging)"]
    B -->|git commit| C["Repositori local<br/>(historial)"]
    C -->|git push| D["GitHub<br/>(remot)"]
    D -->|git pull| A

  • git init — converteix una carpeta en un repositori Git (només el primer cop):
  • git status — indica què has canviat i què està pendent.
  • git add — posa fitxers a la zona d’espera, preparats per guardar.
  • git commit — fa la “foto”: guarda els canvis a l’historial amb un missatge explicatiu.
  • git log — mostra l’historial de commits fets.

Exemple de les comandes bàsiques:

git init                            # Només un cop. Per indicar que és un directori git.
...
git add nomFitxer.java              # Afegeix un fitxer concret
git add .                           # Afegeix tots els fitxers. Excepte els indicats a .gitignore

git commit -m "Primer commit"       # Commit. Captura de l'estat actual. En local.
AlertaError típic: fer commit sense add

Git no guarda el que no has posat a la zona d’espera. Si edites un fitxer i fas git commit directament sense git add, aquell canvi no s’inclou.

El flux és sempre: edita → add → commit. Fes git status abans de cada commit per veure què entrarà.

ConsellBons missatges de commit

Un bon missatge explica què fa el canvi, en present i concret. Compara:

  • Dolent: "canvis", "aaa", "arreglat".
  • Bo: "Corregeix el càlcul de l'IVA a la factura".

Quan s’hagi de revisar, s’agraïrà que el text sigui explicatiu i clar.

E.4 Treballar amb GitHub

Per pujar el codi al núvol necessites un compte a Github o alguna altra eina, com ara Gitlab o Bitbucket.

Un cop tens un repositori creat a GitHub, hi ha dues situacions habituals.

Cas 1: baixar un repositori que ja existeix (per exemple, un exercici del curs). S’anomena clonar:

git clone https://github.com/usuari/nom-repositori.git

Això et crea una carpeta local amb tot el contingut i l’historial, ja connectada al remot.

Cas 2: pujar i baixar canvis. Un cop tens fets i guardats (commit) els teus canvis en local, els envies a GitHub amb push, i te’n baixes els que hi hagi al remot amb pull:

git push        # Puja els teus commits a GitHub
git pull        # Baixa els canvis del remot al teu ordinador
NotaDiferencia entre push i commit
  • commit guarda al teu ordinador. En local, sense Internet.
  • push ho envia a GitHub. En remot.

Pots fer molts commits i, quan vulguis, un sol push per pujar-los tots.

E.5 El fitxer .gitignore per a Java

No tots els fitxers d’un projecte s’han de guardar a Git. Els fitxers compilats (.class), les carpetes que genera l’eina de construcció (target/, build/) i la configuració personal de l’IDE no s’han de pujar: es regeneren sols i només fan soroll.

El fitxer especial .gitignore (amb el punt al davant) diu a Git què ha d’ignorar. Aquest és un .gitignore típic per a un projecte Java amb Maven o Gradle:

# Fitxers compilats de Java
*.class

# Carpetes generades per l'eina de construcció
target/
build/
out/

# Configuració personal de l'IDE
.idea/
*.iml
.vscode/

# Logs i fitxers temporals
*.log
AlertaError típic: pujar la carpeta target/ o .class

Si t’oblides el .gitignore, acabaràs pujant centenars de fitxers .class i la carpeta target/. El repositori s’infla, els canvis es fan il·legibles.

Crea el .gitignore abans del primer commit.

E.6 GitHub Classroom

GitHub Classroom és l’eina que farem servir per repartir i recollir les activitats del curs.

Funciona sobre GitHub: quan acceptes una activitat, se’t crea automàticament un repositori personal amb l’enunciat i la plantilla dins.

Tu hi treballes i, en fer push, el professorat ja hi té accés per corregir.

Aquest és el flux complet que seguiràs per a cada exercici o pràctica:

flowchart TD
    A["1. Rebo l'enllaç<br/>de l'activitat"] --> B["2. Accepto l'activitat<br/>(es crea el meu repo)"]
    B --> C["3. git clone<br/>del meu repo"]
    C --> D["4. Programo<br/>la solució"]
    D --> E["5. git add + commit"]
    E --> F["6. git push"]
    F --> G["7. El professorat<br/>ho veu i corregeix"]
    D -.->|"repeteixo add/commit/push<br/>tantes vegades com calgui"| E

Pas a pas:

  1. Reps un enllaç de l’activitat (te’l dona el professorat a l’aula virtual).
  2. Acceptes l’activitat amb el teu compte de GitHub. Es crea el teu repositori personal (ningú més el veu, tret del professorat).
  3. Clones el teu repositori al teu ordinador amb git clone.
  4. Programes la solució amb el teu IDE.
  5. Guardes els avenços amb git add i git commit (tantes fotos com vulguis).
  6. Puges la feina amb git push.
  7. El professorat veu el teu repositori i el corregeix.
ImportantEl que el professorat corregeix és l’últim push

Pots fer commit i push tantes vegades com vulguis abans de la data límit; sempre es tindrà en compte l’últim estat pujat.

Fes push sovint; així la teva feina sempre està segura al núvol encara que se t’espatlli l’ordinador.

ConsellMini-repte

Crea un repositori de prova a GitHub, clona’l, afegeix-hi un fitxer Hola.java, i fes tot el cicle: add, commit amb un bon missatge i push.

Comprova a la web de GitHub que el fitxer hi ha arribat.

E.7 Resum

  • Un control de versions guarda l’historial del teu codi i et deixa tornar enrere. Git és local; GitHub és el servei web on el publiques.
  • El cicle bàsic és edita → git add → git commit (foto local) → git push (al remot). git pull baixa canvis; git clone copia un repositori sencer.
  • git status i git log t’informen de l’estat i l’historial; fes servir missatges de commit clars.
  • El .gitignore evita pujar fitxers compilats (.class), carpetes generades (target/, build/) i configuració de l’IDE.
  • GitHub Classroom reparteix i recull les activitats: acceptes l’activitat, clones, programes i fas push; el professorat corregeix l’últim estat pujat.
  • Consell clau: fes commit i push sovint, no esperis a l’últim moment.

E.8 Per practicar

  1. *Primer repositori. Crea una carpeta, fes-hi git init i completa el cicle add/commit amb dos o tres fitxers.
  2. Historial. Fes tres commits diferents i mira’ls amb git log --oneline. Identifica què va canviar a cadascun.
  3. .gitignore a la pràctica. En un projecte Java, comprova amb git status que els fitxers .class i la carpeta target/ no apareixen com a pendents.
  4. Simulació de Classroom. Clona un repositori de GitHub, fes-hi un canvi i puja’l amb push. Verifica-ho a la web.
  5. Recuperar feina. Des d’un altre ordinador (o una altra carpeta), fes git clone del teu repositori i comprova que hi tens tota la feina: aquest és el motiu de fer push sovint.