Zelf software op GitHub zetten

In deze workshop gaan we software op GitHub zetten. We laten zien hoe je een repository maakt voor het werken aan een programmeerproject en hoe je ervoor kunt zorgen dat wijzigingen in bestanden wel of juist niet door Git worden gevolgd.

In dit artikel gaan we met Git de wijzigingen bijhouden van een eenvoudig programma. We gebruiken hiervoor overwegend de opdrachtregel op een server met Ubuntu. Onder Windows kun je deze stappen echter ook uitvoeren. Daarvoor kun je de Windows-software voor Git downloaden. Zet bij de installatie het vinkje voor integratie met Windows Verkenner. Je kunt dan in elke map via de rechtermuisknop een bash-opdrachtprompt (Git Bash Here) oproepen om opdrachten te geven. Die opdrachten zijn hetzelfde als in deze workshop. Je kunt eventueel de grafische toepassing (Git GUI Here) oproepen. We zullen er in de workshop een enkele keer naar verwijzen.

Programmeertaal Go

Het voorbeeldprogramma maken we in de programmeertaal Go, die je binnen Ubuntu kunt installeren met de opdracht:

apt get install golang-go

Met de opdracht go version controleer je de installatie en het versienummer. Je kunt de programmeertaal ook onder Windows installeren. Voor de downloadopties ga je naar www.golang.org/dl.

In deze workshop maken we een voorbeeldprogramma in de programmeertaal Go.

Initialisatie

We beginnen in een lege map waarin we straks ons programma gaan maken. De eerste stap is het maken van een repository met Git. Hiervoor geef je de opdracht git init. Hiermee wordt een lege map .git gemaakt waarin Git zijn gegevens kan bewaren. Het is handig om vervolgens je gebruikersnaam en e-mailadres in te stellen met:

git config --global user.name "Jouw Naam"

git config --global user.email jouw@emailadres.nl

Het is dan bij wijzigingen in de repository duidelijk dat jij die hebt gemaakt. Dit is vooral nuttig als je met meerdere mensen samenwerkt aan het programma. Onder Windows kun je deze opdrachten geven via bash. Eventueel kun je ook vanuit de grafische interface een repository maken. Daar stel je vervolgens via Edit / Options eventueel een gebruikersnaam en e-mailadres in.

Ook via de grafische interface van Git kun je een repository maken en beheren.

Voorbeeldprogramma maken volgen

We gaan een klein programma maken. De wijzigingen willen we vervolgens door Git laten bijhouden. We gebruiken binnen Ubuntu de bekende teksteditor nano en geven de opdracht:

nano demo.go

Onder Windows kun je bijvoorbeeld Kladblok gebruiken. We zetten hier de volgende regels in. Dit voorbeeldprogramma laat een tekst op het scherm zien.

package main

import "fmt"

func main() {

fmt.Printf("Hallo wereld\n")

}

Bewaar het bestand met Ctrl+O en verlaat de editor met Ctrl+X. Je voert het programma uit met de opdracht:

go run demo.go

Om het programma te compileren, geef je de opdracht:

go build demo.go

Hierdoor wordt een uitvoerbaar bestand gemaakt dat de naam van de map krijgt waarin het staat, in ons voorbeeld demo. Je kunt het starten met ./demo.

Deze commando’s zijn hetzelfde onder Windows en voer je uit via de gewone Opdrachtprompt. Een verschil is dat het uitvoerbare bestand onder Windows een .exe-bestand is dat je met de opdracht demo.exe via de Opdrachtprompt uitvoert. Je ziet in beide gevallen de tekst Hallo wereld op het scherm verschijnen.

Met een teksteditor maken we een eenvoudig programma in Go.
Downloadbare modules of bestanden met je wachtwoorden horen niet in je repository

Welke bestanden volgen?

Voordat je wijzigingen door Git laat volgen, is het goed te bedenken voor welke bestanden dat nodig is. In dit voorbeeld is eigenlijk alleen demo.go relevant, omdat het uitvoerbare bestand (demo of, onder Windows, demo.exe) altijd opnieuw gecompileerd kan worden voor het platform waarop het wordt gebruikt. Doorgaans zul je ook geen logbestanden tracken of configuratiebestanden met gevoelige wachtwoorden. Je kunt natuurlijk wel een leeg configuratiebestand in de repository opnemen dat als voorbeeld dient, zodat de gebruiker alleen de parameters voor zijn situatie hoeft aan te vullen.

Ook modules houd je doorgaans buiten de repository, zoals de hele map node_modules bij een Node.js-project. Je zult in die situatie doorgaans alleen het bestand package.json toevoegen. In dat bestand definieer je precies welke modules voor je project vereist zijn en in welke versie. Die kunnen dan met één opdracht door de gebruiker worden geïnstalleerd via de pakketbeheerder.

Toevoegen aan staging area

Geef je via de opdrachtregel de opdracht git status, dan zie je dat je in de branch met de naam master werkt en dat de bestanden die Git in de map heeft gevonden als Untracked zijn aangemerkt (demo.go en het uitvoerbare bestand demo of demo.exe). Dat houdt in dat Git ze niet volgt op dit moment en er dus geen wijzigingen voor bijhoudt. Dat gebeurt pas als je ze toevoegt aan de zogeheten staging area, een soort tijdelijke buffer, en van daaruit naar de repository. Om het bestand in de staging area te zetten geef je de opdracht:

it add demo.go

Eventueel werk je met een .gitignore-bestand. Daarin staan bestanden en mappen die door Git worden uitgesloten. Je kunt dan steeds in één handeling gewijzigde bestanden naar de staging area overzetten, zonder bang te zijn dat een bestand met gevoelige inhoud ‘mee’ gaat. Dat doe je met de opdracht:

git add .

Via de opdrachtprompt kun je zien welke veranderingen Git heeft opgemerkt.

Eerste commit

In de vorige stap hebben we de wijzigingen in de staging area gezet. Als je onder Windows de grafische interface van Git opent, zie je het bestand terug onder het kopje Staged Changes. Om de wijzigingen door te zetten naar de repository, geef je de opdracht:

git commit -m "Eerste commit"

Omdat het de eerste keer is dat we iets in de repository zetten, noemen we dit een initial commit. Bij elke commit geef je in de omschrijving normaliter achter -m kort en bondig aan wat er is veranderd. Na de commit wordt onze lokale repository bijgewerkt. De staging area is dan weer leeg en klaar voor eventuele volgende wijzigingen. 

De bestanden hebben we overgezet naar de zogeheten staging area.

Geschreven door: Gertjan Groen op

Category: Workshop, Algemeen

Tags: software, how to, repository, github