18 KiB

Raw Blame History

Introductie tot GitHub

Deze les behandelt de basisprincipes van GitHub, een platform om je code te hosten en wijzigingen te beheren.

Sketchnote door Tomomi Imura

Pre-Lecture Quiz

Pre-lecture quiz

Introductie

In deze les behandelen we:

het bijhouden van het werk dat je op je computer doet
samenwerken aan projecten met anderen
hoe je kunt bijdragen aan open source software

Vereisten

Voordat je begint, moet je controleren of Git is geïnstalleerd. Typ in de terminal: git --version

Als Git niet is geïnstalleerd, download Git. Stel vervolgens je lokale Git-profiel in via de terminal:

git config --global user.name "jouw-naam"
git config --global user.email "jouw-email"

Om te controleren of Git al is geconfigureerd, kun je typen: git config --list

Je hebt ook een GitHub-account nodig, een code-editor (zoals Visual Studio Code), en je moet je terminal (of: command prompt) openen.

Ga naar github.com en maak een account aan als je dat nog niet hebt, of log in en vul je profiel in.

✅ GitHub is niet de enige code-repository ter wereld; er zijn andere, maar GitHub is de bekendste.

Voorbereiding

Je hebt zowel een map met een codeproject op je lokale computer (laptop of pc) nodig, als een openbare repository op GitHub, die als voorbeeld zal dienen voor hoe je kunt bijdragen aan de projecten van anderen.

Codebeheer

Stel dat je lokaal een map hebt met een codeproject en je wilt je voortgang gaan bijhouden met behulp van git - het versiebeheersysteem. Sommige mensen vergelijken het gebruik van git met het schrijven van een liefdesbrief aan je toekomstige zelf. Door je commitberichten dagen, weken of maanden later te lezen, kun je je herinneren waarom je een bepaalde beslissing hebt genomen, of een wijziging "terugdraaien" - dat is, wanneer je goede "commitberichten" schrijft.

Taak: Maak een repository en commit code

Bekijk video

Maak een repository op GitHub. Op GitHub.com, in het tabblad repositories, of via de navigatiebalk rechtsboven, vind je de knop new repo.
1. Geef je repository (map) een naam.
2. Selecteer create repository.
Navigeer naar je werkmap. In je terminal, ga naar de map (ook wel directory genoemd) die je wilt gaan bijhouden. Typ:
```
cd [name of your folder]
```
Initialiseer een git-repository. Typ in je project:
```
git init
```
Controleer de status. Om de status van je repository te controleren, typ:
```
git status
```
De output kan er ongeveer zo uitzien:
```
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)

     modified:   file.txt
     modified:   file2.txt
```
Meestal vertelt een git status-commando je dingen zoals welke bestanden klaar zijn om opgeslagen te worden in de repo of welke wijzigingen erop staan die je mogelijk wilt behouden.
Voeg alle bestanden toe voor tracking Dit wordt ook wel het "stagen" van bestanden genoemd/het toevoegen van bestanden aan de staging area.
```
git add .
```
Het git add-commando met het argument . geeft aan dat alle bestanden en wijzigingen worden bijgehouden.
Voeg geselecteerde bestanden toe voor tracking
```
git add [file or folder name]
```
Dit helpt ons om alleen geselecteerde bestanden toe te voegen aan de staging area wanneer we niet alle bestanden tegelijk willen committen.
Haal alle bestanden uit de staging area
```
git reset
```
Dit commando helpt ons om alle bestanden in één keer uit de staging area te halen.
Haal een specifiek bestand uit de staging area
```
git reset [file or folder name]
```
Dit commando helpt ons om slechts één specifiek bestand uit de staging area te halen dat we niet willen opnemen in de volgende commit.
Je werk opslaan. Op dit punt heb je de bestanden toegevoegd aan een zogenaamde staging area. Een plek waar Git je bestanden bijhoudt. Om de wijziging permanent te maken, moet je de bestanden committen. Dit doe je door een commit te maken met het git commit-commando. Een commit vertegenwoordigt een opslagpunt in de geschiedenis van je repo. Typ het volgende om een commit te maken:
```
git commit -m "first commit"
```
Dit commit alle bestanden en voegt het bericht "first commit" toe. Voor toekomstige commitberichten wil je meer beschrijvend zijn om duidelijk te maken wat voor soort wijziging je hebt aangebracht.
Verbind je lokale Git-repo met GitHub. Een Git-repo is handig op je computer, maar op een gegeven moment wil je een back-up van je bestanden ergens anders hebben en ook andere mensen uitnodigen om met je mee te werken aan je repo. Een geweldige plek om dat te doen is GitHub. We hebben al een repo op GitHub gemaakt, dus het enige wat we moeten doen is onze lokale Git-repo verbinden met GitHub. Het commando git remote add doet precies dat. Typ het volgende commando:

Let op, voordat je het commando typt, ga naar de pagina van je GitHub-repo om de URL van de repository te vinden. Je gebruikt deze in het onderstaande commando. Vervang https://github.com/username/repository_name.git door je GitHub-URL.
```
git remote add origin https://github.com/username/repository_name.git
```
Dit creëert een remote, of verbinding, genaamd "origin" die wijst naar de GitHub-repository die je eerder hebt gemaakt.
Stuur lokale bestanden naar GitHub. Tot nu toe heb je een verbinding gemaakt tussen de lokale repo en de GitHub-repo. Laten we deze bestanden naar GitHub sturen met het volgende commando git push, zoals hieronder:

Let op, je branchnaam kan standaard anders zijn dan main.
```
git push -u origin main
```
Dit stuurt je commits in je "main"-branch naar GitHub.
Meer wijzigingen toevoegen. Als je verder wilt gaan met het maken van wijzigingen en deze naar GitHub wilt pushen, hoef je alleen de volgende drie commando's te gebruiken:
```
git add .
git commit -m "type your commit message here"
git push
```
Tip, je wilt misschien ook een .gitignore-bestand gebruiken om te voorkomen dat bestanden die je niet wilt bijhouden op GitHub verschijnen - zoals dat notitiebestand dat je in dezelfde map opslaat maar geen plaats heeft in een openbare repository. Je kunt sjablonen voor .gitignore-bestanden vinden op .gitignore templates.

Commitberichten

Een geweldig Git-commitonderwerp voltooit de volgende zin: Als toegepast, zal deze commit

Voor het onderwerp gebruik je de gebiedende wijs, tegenwoordige tijd: "verander" in plaats van "veranderd" of "verandert". Net als in het onderwerp, gebruik je in de body (optioneel) ook de gebiedende wijs, tegenwoordige tijd. De body moet de motivatie voor de wijziging bevatten en dit contrasteren met het vorige gedrag. Je legt de waarom uit, niet de hoe.

✅ Neem een paar minuten de tijd om rond te surfen op GitHub. Kun je een echt geweldig commitbericht vinden? Kun je een heel minimaal bericht vinden? Welke informatie denk je dat het belangrijkst en nuttigst is om over te brengen in een commitbericht?

Taak: Samenwerken

De belangrijkste reden om dingen op GitHub te zetten was om het mogelijk te maken samen te werken met andere ontwikkelaars.

Samenwerken aan projecten met anderen

Bekijk video

In je repository, navigeer naar Insights > Community om te zien hoe jouw project zich verhoudt tot aanbevolen communitystandaarden.

Hier zijn enkele dingen die je GitHub-repo kunnen verbeteren:

Beschrijving. Heb je een beschrijving toegevoegd voor je project?
README. Heb je een README toegevoegd? GitHub biedt richtlijnen voor het schrijven van een README.
Bijdragerichtlijnen. Heeft je project bijdragerichtlijnen?
Gedragscode. Een gedragscode.
Licentie. Misschien wel het belangrijkste, een licentie?

Al deze middelen zullen het onboardingproces voor nieuwe teamleden ten goede komen. En dit zijn meestal de dingen waar nieuwe bijdragers naar kijken voordat ze zelfs maar naar je code kijken, om te bepalen of jouw project de juiste plek is om hun tijd te besteden.

✅ README-bestanden, hoewel ze tijd kosten om te maken, worden vaak verwaarloosd door drukke maintainers. Kun je een voorbeeld vinden van een bijzonder beschrijvende README? Opmerking: er zijn enkele tools om goede READMEs te maken die je misschien wilt proberen.

Taak: Code samenvoegen

Bijdragedocumenten helpen mensen bijdragen aan het project. Ze leggen uit welke soorten bijdragen je zoekt en hoe het proces werkt. Bijdragers moeten een reeks stappen doorlopen om te kunnen bijdragen aan jouw repo op GitHub:

Fork je repo. Je wilt waarschijnlijk dat mensen je project forken. Forken betekent dat ze een replica van jouw repository maken op hun GitHub-profiel.
Clone. Vanaf daar zullen ze het project naar hun lokale computer clonen.
Maak een branch. Je wilt dat ze een branch maken voor hun werk.
Focus hun wijziging op één gebied. Vraag bijdragers om hun bijdragen op één ding tegelijk te concentreren - zo is de kans groter dat je hun werk kunt samenvoegen. Stel je voor dat ze een bugfix schrijven, een nieuwe functie toevoegen en verschillende tests bijwerken - wat als je slechts 2 van de 3, of 1 van de 3 wijzigingen wilt of kunt implementeren?

✅ Stel je een situatie voor waarin branches bijzonder belangrijk zijn voor het schrijven en leveren van goede code. Welke gebruiksscenario's kun je bedenken?

Opmerking, wees de verandering die je in de wereld wilt zien, en maak ook branches voor je eigen werk. Alle commits die je maakt, worden gemaakt op de branch waar je momenteel "uitgecheckt" bent. Gebruik git status om te zien op welke branch dat is.

Laten we een workflow voor bijdragers doorlopen. Stel dat de bijdrager de repo al heeft geforkt en gecloned, zodat ze een Git-repo hebben die klaar is om aan te werken op hun lokale computer:

Maak een branch. Gebruik het commando git branch om een branch te maken die de wijzigingen bevat die ze willen bijdragen:
```
git branch [branch-name]
```
Schakel over naar de werkbranch. Schakel over naar de opgegeven branch en werk de werkmap bij met git switch:
```
git switch [branch-name]
```
Doe werk. Op dit punt wil je je wijzigingen toevoegen. Vergeet niet om Git hierover te informeren met de volgende commando's:
```
git add .
git commit -m "my changes"
```
Zorg ervoor dat je je commit een goede naam geeft, zowel voor jezelf als voor de maintainer van de repo waaraan je helpt.
Combineer je werk met de main branch. Op een gegeven moment ben je klaar met werken en wil je je werk combineren met dat van de main branch. De main branch kan ondertussen zijn gewijzigd, dus zorg ervoor dat je deze eerst bijwerkt naar de nieuwste versie met de volgende commando's:
```
git switch main
git pull
```
Op dit punt wil je ervoor zorgen dat eventuele conflicten, situaties waarin Git de wijzigingen niet gemakkelijk kan combineren, plaatsvinden in jouw werkbranch. Voer daarom de volgende commando's uit:
```
git switch [branch_name]
git merge main
```
Dit brengt alle wijzigingen van main naar jouw branch en hopelijk kun je gewoon doorgaan. Zo niet, dan zal VS Code je vertellen waar Git verward is en kun je de getroffen bestanden aanpassen om aan te geven welke inhoud het meest accuraat is.
Stuur je werk naar GitHub. Je werk naar GitHub sturen betekent twee dingen. Je branch naar je repo pushen en vervolgens een PR (Pull Request) openen.
```
git push --set-upstream origin [branch-name]
```
Het bovenstaande commando maakt de branch aan op je geforkte repo.
Open een PR. Vervolgens wil je een PR openen. Dit doe je door naar de geforkte repo op GitHub te navigeren. Je ziet een indicatie op GitHub waar wordt gevraagd of je een nieuwe PR wilt maken. Klik daarop en je wordt naar een interface gebracht waar je de commitberichttitel kunt wijzigen en een meer geschikte beschrijving kunt geven. Nu ziet de maintainer van de repo die je hebt geforkt deze PR en hopelijk waarderen ze het en mergen ze je PR. Je bent nu een bijdrager, yay :)
Ruim op. Het wordt als goede praktijk beschouwd om op te ruimen nadat je succesvol een PR hebt gemerged. Je wilt zowel je lokale branch als de branch die je naar GitHub hebt gepusht opruimen. Laten we eerst de branch lokaal verwijderen met het volgende commando:
```
git branch -d [branch-name]
```

Zorg ervoor dat je naar de GitHub-pagina van de geforkte repository gaat en de remote branch verwijdert die je er net naartoe hebt gepusht.

Pull request lijkt een vreemde term, omdat je eigenlijk je wijzigingen naar het project wilt pushen. Maar de maintainer (projecteigenaar) of het kernteam moet je wijzigingen beoordelen voordat ze worden samengevoegd met de "main" branch van het project. Je vraagt dus eigenlijk om een besluit over je wijziging van een maintainer.

Een pull request is de plek waar je de verschillen die zijn geïntroduceerd op een branch kunt vergelijken en bespreken, met reviews, opmerkingen, geïntegreerde tests en meer. Een goede pull request volgt ongeveer dezelfde regels als een commitbericht. Je kunt een verwijzing naar een issue in de issue tracker toevoegen, bijvoorbeeld wanneer je werk een issue oplost. Dit doe je door een # te gebruiken, gevolgd door het nummer van je issue. Bijvoorbeeld #97.

🤞Fingers crossed dat alle checks slagen en de projecteigenaar(s) je wijzigingen in het project samenvoegen 🤞

Werk je huidige lokale werkbranch bij met alle nieuwe commits van de corresponderende remote branch op GitHub:

git pull

Hoe bij te dragen aan open source

Laten we eerst een repository (of repo) op GitHub vinden die je interesseert en waaraan je een wijziging wilt bijdragen. Je wilt de inhoud ervan naar je computer kopiëren.

✅ Een goede manier om 'beginner-vriendelijke' repos te vinden is door te zoeken op de tag 'good-first-issue'.

Er zijn verschillende manieren om code te kopiëren. Een manier is om de inhoud van de repository te "clonen" met HTTPS, SSH of de GitHub CLI (Command Line Interface).

Open je terminal en clone de repository als volgt: git clone https://github.com/ProjectURL

Om aan het project te werken, ga je naar de juiste map: cd ProjectURL

Je kunt het hele project ook openen met Codespaces, de ingebouwde code-editor / cloudontwikkelomgeving van GitHub, of GitHub Desktop.

Ten slotte kun je de code downloaden in een gezipte map.

Een paar interessante dingen over GitHub

Je kunt elke openbare repository op GitHub ster geven, volgen en/of "forken". Je kunt je gestarred repositories vinden in het drop-down menu rechtsboven. Het is als bladwijzers maken, maar dan voor code.

Projecten hebben een issue tracker, meestal op GitHub in het tabblad "Issues", tenzij anders aangegeven, waar mensen problemen met betrekking tot het project bespreken. En het tabblad Pull Requests is waar mensen wijzigingen die in behandeling zijn bespreken en beoordelen.

Projecten kunnen ook discussies hebben in forums, mailinglijsten of chatkanalen zoals Slack, Discord of IRC.

✅ Kijk eens rond in je nieuwe GitHub-repo en probeer een paar dingen, zoals instellingen bewerken, informatie toevoegen aan je repo en een project maken (zoals een Kanban-bord). Er is veel dat je kunt doen!

🚀 Uitdaging

Werk samen met een vriend om aan elkaars code te werken. Maak samen een project, fork code, maak branches en voeg wijzigingen samen.

Post-Lecture Quiz

Post-lecture quiz

Review & Zelfstudie

Lees meer over bijdragen aan open source software.

Git cheatsheet.

Oefen, oefen, oefen. GitHub heeft geweldige leerpaden beschikbaar via skills.github.com:

Eerste week op GitHub

Je vindt er ook meer gevorderde cursussen.

Opdracht

Voltooi de cursus Eerste week op GitHub.

Disclaimer:
Dit document is vertaald met behulp van de AI-vertalingsservice Co-op Translator. Hoewel we ons best doen om nauwkeurigheid te waarborgen, dient u zich ervan bewust te zijn dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in de oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor cruciale informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.

18 KiB Raw Blame History