Windows Subsystem for Linux (WSL)

Besturingssystemen: introductie

Voor we met de echte materie kunnen starten moeten we eerst wat meer kennis vergaren over hoe computers juist werken. Je zal dit nog met meer diepgang bespreken in het vak ‘Besturingssystemen en C’, maar we geven toch al een korte intro zodat je weet waar we mee bezig zijn.

Wat is een besturingssysteem? (Besturingssysteem = Operating System = OS)

Een besturingssysteem (OS) is een essentieel onderdeel van de computerarchitectuur dat fungeert als een brug tussen de hardware van een computer en de gebruiker. Het beheert de hardwarebronnen van de computer en biedt een omgeving waarin applicaties kunnen draaien. Zonder een besturingssysteem zou een computer niet functioneel zijn voor de meeste gebruikers.

Het besturingssysteem voert verschillende cruciale taken uit:

• hardwarecomponenten (CPU, geheugen …) besturen;
• een platform voorzien waar software/applicaties op kunnen draaien;
• een gebruikersinterface voorzien;
• beheren van processen;
• input en output apparaten beheren;
• applicaties beheren;
• veiligheid beheren.

Dit betekent dat het OS bijvoorbeeld bepaalt welke processen toegang hebben tot welke bronnen en wanneer. Dit beheer is essentieel om ervoor te zorgen dat de computer efficiënt en effectief werkt. We gaan vooral even dieper in hoe het OS applicaties beheert en kan starten/stoppen.

Daarnaast biedt het besturingssysteem een gebruikersinterface, die kan variëren van een command-line interface (CLI) tot een grafische gebruikersinterface (GUI). Deze interface stelt gebruikers in staat om met de computer te interageren. Je bent waarschijnlijk al zeer bekend met de GUI. Tijdens de lessen SES gaan we ons echter focussen op het interageren met de computer via de CLI.

Nog ander belangrijk aspect van een besturingssysteem is het beheer van bestanden. Het OS organiseert en bewaart bestanden op een manier die gemakkelijk toegankelijk en veilig is. Dit omvat het beheren van lees- en schrijfrechten, het organiseren van bestanden in mappen en het zorgen voor gegevensintegriteit. Dit komt later nog aan bod wanneer we het hebben over het beheer van applicaties en het commando chmod.

Zoals hierboven al vermeld, biedt het besturingssysteem een platform voor het uitvoeren van applicaties. Het zorgt ervoor dat applicaties de benodigde bronnen krijgen en dat ze geïsoleerd zijn van elkaar om conflicten en beveiligingsproblemen te voorkomen. Dit maakt het mogelijk om meerdere applicaties tegelijkertijd te draaien zonder dat ze elkaar storen.

In samenvatting, een besturingssysteem is een complex maar essentieel onderdeel dat de functionaliteit en bruikbaarheid van computers mogelijk maakt.

Voorbeelden van besturingssystemen:

• Windows
• Linux
• Mac OS
• FreeRTOS

Van de voorbeelden hierboven kunnen Linux en Mac OS nog gegroepeerd worden tot de zogenaamde UNIX-besturingssystemen omdat ze beide gebaseerd zijn op de principes en architectuur van het oorspronkelijke UNIX-systeem. De CLI werkt bij zowel Linux als Mac OS gelijkaardig, en dit is grotendeels te danken aan hun gemeenschappelijke UNIX-basis.

De Command-Line Interface (CLI)

De CLI is een tekstgebaseerde interface waarmee gebruikers commando’s kunnen invoeren om taken uit te voeren op een computer. In tegenstelling tot GUI’s, waarbij gebruikers met muis en vensters werken, vereist de CLI dat gebruikers tekstcommando’s typen. Hoewel GUI’s tegenwoordig veel gebruiksvriendelijker zijn voor de meeste gebruikers, blijft de CLI een krachtig hulpmiddel voor specifieke taken zoals taken die efficiëntie, automatisering en flexibiliteit vereisen.

Volgende termen houden verband met de CLI en worden soms (incorrect) door elkaar gebruikt:

• Terminal: Een terminal is een apparaat of softwaretoepassing die communicatie tussen de gebruiker en het besturingssysteem mogelijk maakt via de CLI. In de context van moderne computers is een terminal meestal een softwaretoepassing die een CLI-omgeving biedt.

• Terminal Emulator: Een terminal emulator is een softwaretoepassing die de functionaliteit van een traditionele hardwareterminal nabootst. Het stelt gebruikers in staat om een terminalsessie te openen binnen een grafische omgeving en zorgt voor een omgeving waarin een shell kan draaien. Voorbeelden van terminal emulators zijn GNOME Terminal, Konsole en Terminator.

• Shell: Een shell is een programma dat de CLI biedt en de interpretatie van de ingevoerde commando’s verzorgt. Het fungeert als een interface tussen de gebruiker en het besturingssysteem. De shell ontvangt commando’s van de gebruiker, voert ze uit en geeft de output terug.

  • Bash: Bash (Bourne Again Shell) is een veelgebruikte UNIX-shell die vaak standaard wordt geleverd met Linux-distributies. Bash biedt krachtige scriptingmogelijkheden en een breed scala aan ingebouwde commando’s, waardoor het een populaire keuze is voor zowel systeembeheer als ontwikkeling.
  • Zsh: Zsh (Z Shell) is een andere UNIX-shell die bekend staat om zijn uitgebreide functies en configuratiemogelijkheden. Het biedt verbeterde autocompletion, betere scriptingmogelijkheden en een meer aanpasbare omgeving in vergelijking met Bash. Veel gebruikers kiezen voor Zsh vanwege de extra functionaliteit en flexibiliteit.
  • PowerShell: PowerShell is een shell ontwikkeld door Microsoft voor Windows. Het combineert de traditionele CLI met een krachtige scriptingtaal gebaseerd op .NET. PowerShell is ontworpen voor systeembeheer en automatisering, en biedt uitgebreide mogelijkheden voor het beheren van Windows-systemen.

• De verschillende shells gebruiken vaak ook verschillende commando’s voor een gelijkaardige functionaliteit. Zo kan je met het commando pwd de inhoud van een folder/directory weergeven in Bash, terwijl in vroegere versies van PowerShell het commando dir voor gebruikt werd.

• Verschillende terminal emulators hebben bijvoorbeeld verschillende manieren om tekst te copy en pasten in de terminal.

Software programma’s / applicaties

Enkele belangrijke termen:

• Hardware: Hardware is de fysieke machine.
• Software: Software is een programma dat op hardware draait.
• Programma: Een programma is een reeks instructies (in alle vormen en maten). Een software programma is dus een reeks computer instructies.
• Proces: Een proces is een programma dat in het geheugen is geladen van het computersysteem en wordt beheert door het besturingssysteem.
• Applicatie: Een programma dat is ontworpen voor de eindgebruiker voor een specifiek doel. Sommige programma’s zijn algemeen van aard, zoals een besturingssysteem, anderen hebben een specifiek doel zoals tekstverwerking (Word) of draaien niet voor de eindgebruiker maar op de achtergrond (zoals een applicatie dat de hardware monitort).

In het dagelijkse leven is een gebruiker dus vooral aan het interageren met verschillende applicaties op de computer. Je kan applicaties installeren, updaten of deïnstalleren. Als ingenieur of software ontwikkelaar zal je zelf programma’s schrijven of zelfs volledige applicaties en kan het soms nodig zijn om dieper in te gaan in de processen die bezig zijn op je computer.

Hoe een applicatie installeren?

Ten eerste zal je voor de meeste applicaties administrator rechten nodig hebben om een applicatie te installeren. Via een GUI krijg je dan vaak een pop-up, met behulp van de CLI kan je in Windows bijvoorbeeld simpelweg PowerShell met administrator rechten starten. In Linux kan je een commando uitvoeren als “super user” met het commando sudo wat staat voor “super user do”.

1. Executables downloaden

De meeste onder jullie hebben ooit al wel een applicatie gedownload en geïnstalleerd op je computer. Hiervoor heb je waarschijnlijk een .exe file gedownload van het internet op Windows. Dubbelklikken op die file start een process dat alle nodige bestanden installeert met het belangrijkste bestand dat op zichzelf weer een .exe file is. EXE staat dan ook voor “executable” of “iets dat uitgevoerd kan worden”. Door op die laatste file te klikken start je dan meestal je applicatie. Menu iconen en Desktop iconen zijn dan meestal gewoon een link naar die specifieke .exe file die op een speciale plaats op je computer is opgeslagen.

2. Een package manager gebruiken

In een CLI omgeving gaan we echter nergens op kunnen klikken. We gaan hier dan vaak gebruik maken van een package manager die in een online repository op zoek gaat naar de gewilde applicatie en hier dan automatisch de correcte bestanden van gaat downloaden op de juiste plaats. Een package manager is een softwaretool die helpt bij het installeren, updaten, configureren en verwijderen van softwarepakketten op een computer. Voordelen van een package manager zijn:

• Efficiëntie: Bespaart tijd en moeite bij het installeren en beheren van software.
• Betrouwbaarheid: Zorgt ervoor dat alle benodigde afhankelijkheden correct worden geïnstalleerd.
• Beveiliging: Helpt bij het up-to-date houden van software, wat belangrijk is voor beveiligingspatches en bugfixes.
• Gemak: Maakt het eenvoudig om software te vinden, installeren en verwijderen met eenvoudige commando’s. Je kan namelijk met één commando alle applicaties op je computer updaten naar de nieuwste versie.

Populaire package managers zijn:

• Apt voor Ubuntu (Linux)
• Homebrew voor Mac OS
• Chocolatey voor Windows

3. Een fully contained package gebruiken

Er bestaan ook volledig voorverpakte software bestanden. In dat geval zit alles wat nodig is om de applicatie te runnen in één bestand. Dit worden ook wel mobiele applicaties genoemd omdat je ze makkelijk op een usb stick kan zetten en op verschillende computers kan gebruiken zonder dat een volledige installatie nodig is. Een voorbeeld hiervan is “Balena Etcher”. Snap packages en flatpacks zijn hiervan voorbeelden voor Linux.

4. Een applicatie bouwen vanuit de bronbestanden

Je kan ook de bronbestanden/broncode van sommige software downloaden en dan de applicatie zelf bouwen. Hiervoor heb je echter de juiste build tools voor nodig, de juiste dependecies, moet je de bestanden op de juiste plaats zetten … Dit kost veel moeite voor de gebruiker en leidt vaak tot errors waardoor we deze manier liefst niet gebruiken. Soms is er echter geen andere mogelijkheid.

Waar worden de nodige bestanden voor de applicatie bewaard?

Een applicatie bestaat vaak uit meerdere onderdelen/bestanden die tijdens het installeren op je computer gezet worden (behalve in fully contained packages, want daar zitten juist alle nodige bestanden in één bestand), maar waar worden deze dan gezet zodat je deze later kan gebruiken?

In Windows heb je waarschijnlijk al eens gekeken in C:\\Program Files, wat meestal de default locatie is voor applicaties. In deze directory wordt er per applicatie meestal een map aangemaakt waar de nodige bestanden inkomen.
In Linux worden de meeste executables geplaatst in /usr/bin of /usr/local/bin.
In Mac OS worden applicaties meestal geïnstalleerd in de Applications-map, die zich in de root van het bestandssysteem bevindt.

Hoe een applicatie starten?

Je kan natuurlijk gewoon dubbelklikken op het icoontje of de executable file zoals je waarschijnlijk altijd al gedaan hebt in een GUI. Dit kan wel weer niet in een CLI omgeving. Hiervoor gebruiken we de naam van de executable file. Als ik in mijn huidige directory een executable heb staan met de naam myprogram, dan kan ik deze applicatie/dit commando simpelweg uitvoeren door de naam in te typen in de CLI. Ik kan echter ook applicaties starten met hun commandonaam die niet in deze specifieke folder zitten. Het OS heeft namelijk een lijst met alle folders waar die moet gaan zoeken naar commando’s. Die lijst staat opgeslagen in de PATH-variabele.

Virtual Machines en WSL

Een virtual machine (VM) is een software-emulatie van een fysieke computer die een besturingssysteem en applicaties kan draaien alsof het een echte machine is. VM’s maken gebruik van hypervisors om de hardwarebronnen van een fysieke hostmachine te verdelen en te isoleren, waardoor meerdere virtuele machines tegelijkertijd op dezelfde fysieke hardware kunnen draaien.

Het principe van virtual machines bestaat al lange tijd en kan soms ingewikkeld zijn om op te zetten, vooral op Windows. Daarom heeft Windows onlangs een ingebouwde oplossing geïntroduceerd genaamd het Windows Subsystem voor Linux (WSL). WSL biedt een Linux-omgeving binnen Windows, waarbij WSL 2 gebruikmaakt van een lichte virtuele machine met een volledige Linux-kernel, wat zorgt voor betere prestaties en integratie dan traditionele VM’s.

Wij gaan de Linux distributie Ubuntu versie 24.04 gebruiken in deze cursus. Een Linux distributie is een complete verzameling van software die een Linux-kernel bevat, samen met een reeks tools, bibliotheken en applicaties die nodig zijn om een volledig functioneel besturingssysteem te vormen. Elke distributie is samengesteld en geoptimaliseerd voor verschillende doeleinden en gebruikersgroepen. Linux distributies verschillen van elkaar op gebied van verschillende aspecten, waaronder: package manager, desktop omgeving, vooraf geïnstalleerde software en tools …
Populaire Linux distributies zijn: Ubuntu, Debian, Pop OS, Fedora, Debian, Linux Mint, Arch Linux …

Wij kiezen voor Ubuntu voor de gebruiksvriendelijkheid, community en ondersteuning, softwarebeschikbaarheid, regelmatige update.

WSL installeren op Windows 11

Voor Windows 10 version 2004 en hoger is het commando wsl normaal al geïnstalleerd. Je kan dit testen door Terminal of PowerShell te openen en het commando wsl --version in te geven. Krijg je een antwoord terug zonder error dan werk WSL. Je kan nu het volgende commando gebruiken om Ubuntu 24.04 te installeren: wsl --install -d Ubuntu-24.04. Na de installatie wordt je meteen in de VM gegooid en moet je een username en password meegeven. Zorg ervoor dat je deze onthoudt! Je kan via WSL meerdere WMs tegelijkertijd installeren op je computer, daarom zetten we Ubuntu even als de default via het commando wsl --set-default Ubuntu-24.04. Wanneer je nu de Windows applicatie WSL opent zal je rechtstreeks in de CLI omgeving van Ubuntu terecht komen. Hier gaan we voorlopig het grootste deel van onze tijd doorbrengen.

PS C:\Users\u0158802> wsl --install -d Ubuntu-24.04
Installing: Ubuntu 24.04 LTS
Failed to install Ubuntu-24.04 from the Microsoft Store: The Windows Subsystem for Linux instance has terminated.
Attempting web download...
Downloading: Ubuntu 24.04 LTS
Installing: Ubuntu 24.04 LTS
Ubuntu 24.04 LTS has been installed.
Launching Ubuntu 24.04 LTS...
Installing, this may take a few minutes...
Please create a default UNIX user account. The username does not need to match your Windows username.
For more information visit: https://aka.ms/wslusers
Enter new UNIX username: arne
New password:
Retype new password:
passwd: password updated successfully
Installation successful!
To run a command as administrator (user "root"), use "sudo <command>".
See "man sudo_root" for details.

Welcome to Ubuntu 24.04 LTS (GNU/Linux 5.15.167.4-microsoft-standard-WSL2 x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/pro

 System information as of Mon Feb 10 17:20:37 CET 2025

  System load:  0.62                Processes:             53
  Usage of /:   0.1% of 1006.85GB   Users logged in:       0
  Memory usage: 12%                 IPv4 address for eth0: 172.29.161.86
  Swap usage:   0%


This message is shown once a day. To disable it please create the
/home/arne/.hushlogin file.
arne@LT3210121:~$

WSL starten, stoppen

Je kan WSL ook starten vanuit een Windows CLI tool zoals Terminal of Powershell met het commando wsl. Om dan uit je WSL te raken en terug in de host versie van de CLI gebruik je het commando exit.

Overzicht commando’s:

> wsl --version
> wsl --install -d [distributie naam]
> wsl --set-default [distributie naam]
# binnenin WSL gebruik je `exit` om terug naar de host te keren
$ exit

Connectie tussen host en VM

Eén van de handige functies van het WSL is de naadloze integratie tussen de WSL-omgeving en de Windows-host. Dit betekent dat je eenvoudig bestanden kunt bekijken en bewerken die zich op je Windows-bestandssysteem bevinden vanuit de WSL-omgeving, en omgekeerd.

filesystem Windows vs Linux

Er is nog een vrij groot verschil tussen het bestandssysteem van Windows en Linux en kan invloed hebben op hoe je met bestanden en mappen werkt.

• De root/hoofd directory in Windows is meestal een specifieke schijf, zoals C:\. Elke schijf of partitie heeft zijn eigen root, bijvoorbeeld D:\ voor een tweede schijf.In Linux is er één enkele root directory aangeduid met /.
• Windows gebruikt backslashes ‘' om directories te scheiden, bijvoorbeeld C:\Users\Gebruiker\Documents. Linux gebruikt forward slashes ‘/’ voor hetzelfde doel, bijvoorbeeld /home/gebruiker/documents.
• In Windows zijn bestandsnamen niet hoofdlettergevoelig. Document.txt en document.txt worden als hetzelfde bestand beschouwd. Linux is wel hoofdlettergevoelig.
• In Windows worden schijven en partities aangeduid met letters zoals C:\, D:\. In Linux worden schijven en partities gekoppeld aan directories binnen het filesystem, zoals /mnt/c voor de C-schijf.

files van VM op host en files van de host op de VM

Binnenin File Explorer (Verkenner) in Windows kan je de files van de WSL terugvinden op de locatie \\wsl$\Ubuntu-24.04 zoals op onderstaande afbeelding te zien is.

In WSL vind je de bestanden van de Windows host in de directory /mnt/c.

De CLI gebruiken: essentiële UNIX commands

Dan kunnen we nu eindelijk aan het praktische deel beginnen. Dingen doen binnen in je WSL Ubuntu met behulp can CLI-commando’s. We gaan een reeks van veelgebruikte commando’s overlopen en bekijken. We gaan echter niet alle commando’s zien omdat er gewoon teveel zijn en ook niet voor elk commando elke optie die mogelijk is. Maar met alles wat we gaan overlopen zou je het grootste deel van je taken als een ingenieur in de CLI moeten kunnen uitvoeren.

We gebruiken een bash shell.

pwd - ‘print working directory’: Met dit commando output je je huidige directory in de terminal.

$ pwd 
# Voorbeeld
arne@LT3210121:~$ pwd
/home/arne

Je huidige directory is ook steeds terug te vinden tussen de : en de $ in de terminal. In het voorbeeld hierboven zie je dat de directory ~ is aangegeven. Dit is een synoniem voor de /home/$USER directory. (Voor de @ staat de ingelogde usernaam en tussen de @ en de : staat de naam van het apparaat)

echo: Met dit commando toon je de opgegeven tekst in de terminal.

$ echo [tekst] 
# Voorbeeld
arne@LT3210121:~$ echo "Hello world!"
Hello world!

clear: Met dit commando maak je het terminalvenster leeg.

$ clear

mkdir - ‘make directory’: Met dit commando maak je een nieuwe directory aan.

$ mkdir [directory]
# Voorbeeld
arne@LT3210121:~$ mkdir test 

cd - ‘change directory’: Met dit commando verander je naar de opgegeven directory.

$ cd [directory]
# Voorbeeld
arne@LT3210121:~$ cd test  
arne@LT3210121:~/test$

Je kan op twee manieren een directory opgeven, namelijk met een relatief pad of een absoluut pad:

• Een absoluut pad geeft de volledige locatie van een directory of bestand vanaf de root directory van het bestandssysteem. Het begint altijd met een / en specificeert de exacte locatie, ongeacht de huidige werkdirectory. (bijvoorbeeld: /home/arne/test)
• Een relatief pad geeft de locatie van een directory of bestand ten opzichte van de huidige werkdirectory. Het begint niet met een /, maar met de naam van de directory of bestand. Relatieve paden zijn handig voor het navigeren binnen de huidige directorystructuur zonder de volledige padnaam te hoeven opgeven. (bijvoorbeeld: arne/test als je je in de /home directory bevindt)
  Bovendien zijn er nog twee speciale symbolen die je in padnamen kan gebruiken . en ..:
• . verwijst naar de huidige directory. (bijvoorbeeld: ./arne/test als je je in de /home directory bevindt)
• .. verwijst naar de bovenliggende directory (= parent directory). (bijvoorbeeld: ./arne/../arne/test als je je in de /home directory bevindt, waarbij je met .. terug naar de /home verwijst, de parent directory van /home/arne)

Voor de meeste commando’s kan je de tab-toets gebruiken om automatisch je text of commando’s te laten vervolledigen. Bijvoorbeeld voor directory of file namen … Als er meerdere mogelijkheden voor autocomplete zijn moet je tweemaal op de tab-toets drukken en dan krijg je een lijst te zien met alle mogelijkheden.

ls - ’list files’: Met dit commando lijst je de bestanden en directories in de huidige directory op.

$ ls
# Voorbeeld
arne@LT3210121:~$ ls
test

Je kan meestal je commando meer specificeren met behulp van options en flags om extra functionaliteit toe te voegen of de uitvoer aan te passen. Bijvoorbeeld, het ls-commando in Linux wordt gebruikt om de inhoud van een directory weer te geven. Door opties en flags toe te voegen, kun je de uitvoer van ls aanpassen aan je behoeften. Zo geeft ls -l een gedetailleerde lijst weer met extra informatie zoals bestandsrechten, eigenaar en grootte, terwijl ls -a ook verborgen bestanden toont die normaal gesproken niet zichtbaar zijn. Je kunt ook meerdere opties combineren, zoals ls -la, om zowel een gedetailleerde lijst als verborgen bestanden weer te geven. Deze flexibiliteit maakt het mogelijk om commando’s nauwkeurig af te stemmen op specifieke taken en vereisten. Je hebt verder ook de optie om aan het ls commando een specifiek directory mee te geven waardoor het de inhoud van de meegegeven directory toont.

# Voorbeeld
arne@LT3210121:~$ ls -l
total 4
drwxr-xr-x 2 arne arne 4096 Feb 10 23:01 test
# Voorbeeld
arne@LT3210121:~$ ls -a
.   .aws    .bash_history  .bashrc  .docker      .profile                  .sudo_as_admin_successful
..  .azure  .bash_logout   .cache   .motd_shown  .skip-cloud-init-warning  test
# Voorbeeld
arne@LT3210121:~$ ls -la
total 36
drwxr-x--- 5 arne arne 4096 Feb 11 14:26 .
drwxr-xr-x 4 root root 4096 Feb 10 17:21 ..
lrwxrwxrwx 1 arne arne   26 Feb 11 14:26 .aws -> /mnt/c/Users/u0158802/.aws
lrwxrwxrwx 1 arne arne   28 Feb 11 14:26 .azure -> /mnt/c/Users/u0158802/.azure
-rw------- 1 arne arne    9 Feb 10 17:27 .bash_history
-rw-r--r-- 1 arne arne  220 Feb 10 17:21 .bash_logout
-rw-r--r-- 1 arne arne 3771 Feb 10 17:21 .bashrc
drwx------ 2 arne arne 4096 Feb 10 17:21 .cache
drwxr-xr-x 5 arne arne 4096 Feb 11 14:26 .docker
-rw-r--r-- 1 arne arne    0 Feb 11 14:26 .motd_shown
-rw-r--r-- 1 arne arne  807 Feb 10 17:21 .profile
-rw-r--r-- 1 arne arne    0 Feb 11 14:26 .skip-cloud-init-warning
-rw-r--r-- 1 arne arne    0 Feb 10 22:20 .sudo_as_admin_successful
drwxr-xr-x 2 arne arne 4096 Feb 10 23:01 test
# Voorbeeld
arne@LT3210121:~$ ls /mnt
c  wsl  wslg

In de output bovenaan van het commando ls -l krijg je meer info te zien over het bestandstype (d = directory, - = file …) en de eigenaarsrechten (r = can read, w = can write, x = can execute). De output bevat verschillende kolommen met belangrijke informatie.

• De eerste kolom toont de bestandsrechten, die aangeven wie lees-, schrijf- en uitvoerrechten heeft voor het bestand (bijvoorbeeld -rw-r--r--). De rechten komen in 3 groeperingen van 3 waarvan de meest linkse de rechten van de eigenaar zijn, de middelste groepering de rechten van alle users in dezelfde groep als de eigenaar en de meest rechtse groepering de rechten van alle gebruikers op het systeem.
• De tweede kolom geeft het aantal harde links naar het bestand weer.
• De derde en vierde kolommen tonen respectievelijk de eigenaar en de groep waartoe het bestand behoort.
• De vijfde kolom geeft de bestandsgrootte in bytes weer. De zesde kolom toont de datum en tijd van de laatste wijziging.
• De laatste kolom geeft de naam van het bestand of de directory weer.

man - ‘manual’: Dit commando is een krachtig hulpmiddel in Linux om gedetailleerde informatie over andere commando’s en hun opties te vinden.

$ man [commando]
# Voorbeeld
arne@LT3210121:~$ man ls
LS(1)                                               User Commands                                               LS(1)

NAME
       ls - list directory contents

SYNOPSIS
       ls [OPTION]... [FILE]...

DESCRIPTION
       List  information  about the FILEs (the current directory by default).  Sort entries alphabetically if none of
       -cftuvSUX nor --sort is specified.

       Mandatory arguments to long options are mandatory for short options too.

       -a, --all
              do not ignore entries starting with .

       -A, --almost-all
              do not list implied . and ..

       --author
              with -l, print the author of each file

       -b, --escape
              print C-style escapes for nongraphic characters

       --block-size=SIZE
              with -l, scale sizes by SIZE when printing them; e.g., '--block-size=M'; see SIZE format below

 Manual page ls(1) line 1 (press h for help or q to quit)

Door man te gebruiken gevolgd door de naam van een commando, zoals man ls, krijg je toegang tot de handleidingspagina voor dat commando (gebruik de pijltjes toetsen om te navigeren en ‘q’ om dit menu te sluiten). Deze pagina bevat uitgebreide informatie over wat het commando doet, welke opties en flags beschikbaar zijn, en hoe je ze kunt gebruiken. Bijvoorbeeld, door man ls in te voeren, zie je een lijst van alle beschikbare opties voor het ls-commando, zoals -l voor een gedetailleerde lijstweergave en -a om verborgen bestanden te tonen. Dit maakt het man-commando een onmisbaar hulpmiddel voor zowel beginners als gevorderde gebruikers om de volledige functionaliteit van Linux-commando’s te ontdekken en effectief te benutten.

touch: Met dit commando maak je een nieuw, leeg bestand aan of update je de timestamp van een bestaand bestand.

$ touch [bestandsnaam]
# Voorbeeld
arne@LT3210121:~$ touch test.txt
arne@LT3210121:~$ ls
test  test.txt

rm - ‘rm [bestand]’: Met dit commando verwijder je het opgegeven bestand. Gebruik de -R (recursive) flag to delete entire directories.

$ rm [bestandsnaam]
$ rm -R [directorynaam]
# Voorbeeld
arne@LT3210121:~$ ls
test  test.txt
arne@LT3210121:~$ rm test.txt
arne@LT3210121:~$ ls
test
arne@LT3210121:~$ rm -R test
arne@LT3210121:~$ ls
arne@LT3210121:~$

nano: Met dit commando open je het opgegeven bestand in de nano-teksteditor. Aangezien nano een CLI teksteditor is, kan je niet gewoon klikken om de cursor te verplaatsen, op te slaan of te exitten. Gebruik hiervoor de pijltjestoetsen, Ctrl+o (= save, write out), Ctrl+x (= exit). Indien het bestand bestaat kan je het aanpassen en indien het bestand niet bestaat wordt het on save aangemaakt.

$ nano [bestandsnaam]
# Voorbeeld
arne@LT3210121:~$ nano test.txt
...

vim: Met dit commando open je het opgegeven bestand in de vim-teksteditor. Dit is een zeer speciale editor. Het belangrijkste dat je moet weten is dat je kan exiten met :q!+enter. Soms moet je eerst tweemaal op esc drukken. Meer info vind je hier.

$ vim [bestandsnaam]
# Voorbeeld
arne@LT3210121:~$ vim test.txt
...

cat - ‘cat [bestand]’: Met dit commando toon je de inhoud van het opgegeven bestand in de terminal.

$ cat [bestandsnaam]
# Voorbeeld
arne@LT3210121:~$ cat test.txt
Dit is een test file.

copy en paste: Dit zal voor verschillende terminal emulators anders zijn. In Windows terminal kan je simpelweg Ctrl+c en Ctrl+v gebruiken, in WSL kan je Ctrl+c gebruiken voor copy en rechtermuisklik voor paste en een andere veel gebruikte toetsencombinatie is Ctrl+Shift+c en Ctrl+Shift+v.

Maak nu de oefeningen van oefenreeks 1 van de volgende pagina

chown - ‘change ownership’: Met dit commando verander je de eigenaar van het opgegeven bestand.

$ sudo chown [gebruiker]:[groep] [bestandsnaam]
# Voorbeeld
arne@LT3210121:~$ chown root:root test.txt
chown: changing ownership of 'test.txt': Operation not permitted
arne@LT3210121:~$ sudo chown root:root test.txt
[sudo] password for arne:
arne@LT3210121:~$ ls -l
total 8
drwxr-xr-x 2 arne arne 4096 Feb 11 14:55 test
-rw-r--r-- 1 root root   22 Feb 11 14:52 test.txt

export: Met dit commando kun je omgevingsvariabelen instellen die beschikbaar zijn voor de huidige shell-sessie en alle sub-processen die vanuit deze shell worden gestart.

$ export [VARIABELENAAM]=[waarde]
# Voorbeeld
arne@LT3210121:~$ export TEST=testwaarde
arne@LT3210121:~$ echo $TEST
testwaarde
# Er zijn ook al voorgedefinieerde variabelen zoals de huidige user ($USER)
arne@LT3210121:~$ echo $USER
arne

chmod - ‘change mode’: Met dit commando verander je de bestandsrechten van het opgegeven bestand. (+r,+w,+x,-r,-w,-x)

$ chmod [rechten] [bestand]
# Voorbeeld
arne@LT3210121:~$ ls -l
total 8
drwxr-xr-x 2 arne arne 4096 Feb 11 14:55 test
-r--r--r-- 1 arne arne   22 Feb 11 14:52 test.txt

arne@LT3210121:~$ chmod -w test.txt
arne@LT3210121:~$ ls -l
total 8
drwxr-xr-x 2 arne arne 4096 Feb 11 14:55 test
-r--r--r-- 1 arne arne   22 Feb 11 14:52 test.txt

arne@LT3210121:~$ chmod +x test.txt
arne@LT3210121:~$ ls -l
total 8
drwxr-xr-x 2 arne arne 4096 Feb 11 14:55 test
-r-xr-xr-x 1 arne arne   22 Feb 11 14:52 test.txt

mv - ‘move’: Met dit commando verplaats of hernoem je een bestand of directory.

$ mv [bron] [doel]
# Voorbeeld
arne@LT3210121:~$ mv ./test.txt ./test/test.txt
arne@LT3210121:~$ ls -l ./test
total 4
-rw-r--r-- 1 arne arne 22 Feb 11 14:52 test.txt

cp - ‘cp [bron] [doel]’: Met dit commando kopieer je een bestand of directory naar een nieuwe locatie.

$ mv [bron] [doel]
# Voorbeeld
arne@LT3210121:~$ cp ./test/test.txt ./test.txt
arne@LT3210121:~$ ls -l ./test
total 4
-rw-r--r-- 1 arne arne 22 Feb 11 14:52 test.txt

arne@LT3210121:~$ ls -l
total 8
drwxr-xr-x 2 arne arne 4096 Feb 11 16:27 test
-rw-r--r-- 1 arne arne   22 Feb 11 16:29 test.txt

sudo apt update - APT staat voor Advanced Packaging Tool: Met dit commando vernieuw je de lijst van beschikbare applicatie packages en hun versies, maar installeert of verwijdert geen packages.
sudo apt upgrade: Met dit commando installeer je de nieuwste versies van alle geïnstalleerde applicatie packages die kunnen worden bijgewerkt, zonder nieuwe packages te verwijderen.
apt install: Met dit commando installeer je het opgegeven pakket op een Debian-gebaseerd systeem.

$ sudo apt install [packagenaam]
# Voorbeeld
arne@LT3210121:~$ sudo apt install curl
[sudo] password for arne:
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
curl is already the newest version (8.5.0-2ubuntu10.6).
curl set to manually installed.
The following package was automatically installed and is no longer required:
  libllvm17t64
Use 'sudo apt autoremove' to remove it.
0 upgraded, 0 newly installed, 0 to remove and 2 not upgraded.

apt search - ‘apt search [pakket]’: Met dit commando zoek je naar een pakket in de pakketbronnen.

$ sudo apt search [zoekterm]
# Voorbeeld
arne@LT3210121:~$ sudo apt search curl
Sorting... Done
Full Text Search... Done
ario/noble 1.6-1.2build4 amd64
  GTK+ client for the Music Player Daemon (MPD)

ario-common/noble 1.6-1.2build4 all
  GTK+ client for the Music Player Daemon (MPD) (Common files)

cht.sh/noble 0.0~git20220418.571377f-2 all
  Cht is the only cheat sheet you need

cl-curry-compose-reader-macros/noble 20171227-1.1 all
...

apt remove: Met dit commando verwijder je het opgegeven pakket van het systeem.

$ sudo apt remove [packagenaam]
# Voorbeeld
arne@LT3210121:~$ sudo apt remove curl
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following packages were automatically installed and are no longer required:
  libcurl4t64 libllvm17t64
Use 'sudo apt autoremove' to remove them.
The following packages will be REMOVED:
  curl ubuntu-wsl
0 upgraded, 0 newly installed, 2 to remove and 2 not upgraded.
After this operation, 551 kB disk space will be freed.
Do you want to continue? [Y/n] y
(Reading database ... 40775 files and directories currently installed.)
Removing ubuntu-wsl (1.539.2) ...
Removing curl (8.5.0-2ubuntu10.6) ...
Processing triggers for man-db (2.12.0-4build2) ...

sleep: Met dit commando pauzeer je de uitvoering van commando’s voor het opgegeven aantal seconden.

$ sleep [seconden]
# Voorbeeld
arne@LT3210121:~$ sleep 5

ctrl+c - ‘ctrl+c’: Met deze toetsencombinatie beëindig je het huidige proces in de terminal.

# Voorbeeld
arne@LT3210121:~$ sleep 5
^C
arne@LT3210121:~$

commando’s aaneenschakelen met ; of &&: je kan ze gebruiken om meerdere commando’s aan elkaar te schakelen, maar ze werken op verschillende manieren. De ; operator voert de commando’s sequentieel uit, ongeacht of het vorige commando succesvol was of niet. De && voert operator het tweede commando alleen uit als het eerste commando succesvol is (d.w.z. een exitstatus van 0 heeft). Dit maakt && nuttig voor het uitvoeren van afhankelijkheden, waar het tweede commando alleen zinvol is als het eerste commando slaagt.

# Voorbeeld ;
arne@LT3210121:~$ cat test.txt; echo "two"
Dit is een test file.
two

arne@LT3210121:~$ cat onbestaand.txt; echo "two"
cat: onbestaand.txt: No such file or directory
two
# Voorbeeld &&
arne@LT3210121:~$ cat test.txt && echo "two"
Dit is een test file.
two

arne@LT3210121:~$ cat onbestaand.txt && echo "two"
cat: onbestaand.txt: No such file or directory

»: Met deze operator voeg je de output van een commando toe aan het einde van een bestand.

$ [commando met output] >> [bestand]
# Voorbeeld
arne@LT3210121:~$ cat test.txt
Dit is een test file.

arne@LT3210121:~$ echo "Hello" >> test.txt
arne@LT3210121:~$ cat test.txt
Dit is een test file.
Hello

>: Met deze operator operator kun je de output van een commando naar een bestand sturen, waarbij de inhoud van het bestand wordt overschreven als het bestand al bestaat.

$ [commando met output] >> [bestand]
# Voorbeeld
arne@LT3210121:~$ cat test.txt
Dit is een test file.

arne@LT3210121:~$ echo "Hello" > test.txt
arne@LT3210121:~$ cat test.txt
Hello

Wildcards (*): Met de wildcard operator kun je patronen specificeren die overeenkomen met meerdere bestanden of directories in één keer. Dit is vooral handig bij het uitvoeren van bewerkingen op groepen bestanden zonder dat je elk bestand afzonderlijk hoeft te specificeren. Bijvoorbeeld kopieer alle bestanden met een bepaalde extensie naar een map: cp *.txt doelmap/

Maak nu de oefeningen van oefenreeks 2 en 3 van de volgende pagina

EXTRA: hier nog een lijst van nuttige commando’s en principes die we voorlopig niet verder in diepgang gaan bespreken, maar wel handig kunnen zijn in je ingenieurs carrière:

• grep
• het principe van piping |
• ssh
• het principe van background processes met & of Ctrl+z
• fg
• curl
• ping
• het principe van de bashrc-file
• source
• fancy printouts
• het principe van signal interrupts
• regular expressions

Shell scripts

Een shell script is een tekstbestand dat een reeks commando’s bevat die door een Unix-shell worden uitgevoerd. Shell scripts worden vaak gebruikt om taken te automatiseren, zoals systeembeheer, batchverwerking en het uitvoeren van complexe commando’s. Een belangrijk onderdeel van een shell script is de shebang (#!), die aangeeft welke interpreter moet worden gebruikt om het script uit te voeren. Voor een Bash-script wordt vaak de volgende shebang gebruikt: #!/bin/bash. Dit vertelt het systeem dat het script moet worden uitgevoerd met de Bash-shell.

Voorbeeld van een eenvoudig shell script: test.sh

#!/bin/bash
# Dit is een eenvoudig shell script dat een begroeting weergeeft en een lijst van bestanden in de huidige directory toont.

echo "Hallo, wereld!"
echo "Hier is een lijst van bestanden in de huidige directory:"
ls -l

Om een shell script uitvoerbaar te maken, moet je het bestand de juiste permissies geven met het chmod-commando. Dit doe je door de uitvoerbare permissie toe te voegen met chmod +x. Dan kan je het shell script uitvoeren met de naam van het .sh-bestand.

Variabelen in een Shell Script

In een shell script kun je variabelen gebruiken om gegevens op te slaan en te manipuleren. Variabelen worden zonder spaties gedefinieerd en kunnen later in het script worden opgeroepen door een $-teken voor de variabelenaam te plaatsen.

Voorbeeld van een shell script met variabelen:

#!/bin/bash
# Dit script gebruikt variabelen om een begroeting weer te geven.

NAAM="Alice"
echo "Hallo, $NAAM! Welkom bij het shell scripting."

Opties meegeven en/of input uitlezen

Je kunt een shell script zo schrijven dat het invoer van de gebruiker accepteert via de commandline of tijdens de uitvoering van het script. Hier is een voorbeeld van beide methoden:

Voorbeeld: Invoer via de commandline

#!/bin/bash
# Dit script accepteert een naam als argument en geeft een begroeting weer.

NAAM=$1
echo "Hallo, $NAAM! Welkom bij het shell scripting."

Om dit script uit te voeren, geef je de naam op als argument:

./script.sh Alice

Merk op dat $0 het commando zelf is!

Voorbeeld: Invoer tijdens de uitvoering

#!/bin/bash
# Dit script vraagt de gebruiker om een naam in te voeren en geeft een begroeting weer.

echo "Voer je naam in:"
read NAAM
echo "Hallo, $NAAM! Welkom bij het shell scripting."

Voorbeeld: conditional statements

#!/bin/bash
# Dit script controleert de waarde van een variabele en geeft een bericht weer op basis van de waarde.

echo "Voer een getal in:"
read getal

if [ $getal -lt 10 ]; then
  echo "Het getal is kleiner dan 10."
elif [ $getal -eq 10 ]; then
  echo "Het getal is precies 10."
else
  echo "Het getal is groter dan 10."
fi

Merk op dat je eindigt met fi

Lijst met conditions:

• &&: logische AND
• ||: logische OR
• !: logische NOT
• -eq of ==: equals
• -ne of !=: not equals
• -lt of <: less than
• -le of <=: less than or equals
• -gt of >: greater than
• -le of >=: greater than or equals

Voorbeeld: for-loop

#!/bin/bash
# Dit script gebruikt een for-loop om een reeks bestanden te maken met oplopende getallen in de bestandsnamen.

# Beginwaarde van het getal
start=1

# Eindwaarde van het getal
eind=5

# Gebruik een for-loop om door de reeks getallen te itereren
for ((i=start; i<=eind; i++)); do
  bestandsnaam="bestand_$i.txt"
  touch "$bestandsnaam"
  echo "Bestand aangemaakt: $bestandsnaam"
done

Merk op dat je eindigt met done

Voorbeeld: while-loop

#!/bin/bash
# Dit script gebruikt een while-loop om een getal te verhogen en weer te geven totdat het een bepaalde waarde bereikt.

# Beginwaarde van het getal
getal=1

# Eindwaarde van het getal
eind=5

# Gebruik een while-loop om het getal te verhogen en weer te geven
while [ $getal -le $eind ]; do
  echo "Huidig getal: $getal"
  getal=$((getal + 1))
done

Merk op dat je eindigt met done

Maak nu de oefeningen van oefenreeks 4 van de volgende pagina

Wat moet ik hier nu allemaal van kennen/kunnen?

Het doel van deze informatie is dat je vlot je weg kan vinden in een OS met behulp van enkel een CLI. Je hoeft geen theorie te kennen, maar je moet wel simpele commando’s kunnen gebruiken en kennen zoals: Met welk commando navigeer je naar de directory /home/arne/test door gebruik te maken van een relatief pad wanneer je je in de directory /home/arne bevindt? OPLOSSING: $ cd test of $ cd ./test.

Heb je nog meer vragen over hoe de commando’s werken, gebruik dan het man-commando of zoek de documentatie op op het internet.

Oefeningen op de CLI

De gegeven oplossingen zijn EEN mogelijke oplossing, soms zijn meerdere mogelijkheden juist. Is het gewenste gedrag bereikt, dan is je oplossing correct!

Oefeningenreeks 1

• Toon het pad van de huidige werkdirectory.

Solution: $ pwd

• Maak een nieuw leeg bestand genaamd nieuwbestand.txt.

Solution: $ touch nieuwbestand.txt

• Maak een nieuwe directory genaamd testmap.

Solution: $ mkdir testmap

• Verwijder een bestand genaamd nieuwbestand.txt.

Solution: $ rm nieuwbestand.txt

• Voeg de tekst “Hallo, wereld!” toe aan de terminaloutput.

Solution: $ echo "Hallo, wereld!"

• Navigeer naar je home directory.

Solution: $ cd ~

• Wis de output van je terminal.

Solution: $ clear

• Bekijk de handleiding voor het commando dat bestanden en directories weergeeft.

Solution: $ man cd

• Toon de inhoud van de huidige directory.

Solution: $ ls

• Open het bestand nieuwbestand.txt in een teksteditor en voeg de tekst “Dit is een test.” toe. Sla het bestand op en sluit de editor.

Solution:

$ nano nieuwbestand.txt
# save met Ctrl+o en Enter. Exit met Ctrl+x 

• Toon de inhoud van nieuwbestand.txt in de terminal.

Solution: $ cat nieuwbestand.txt

• Maak een nieuw directory genaamd project, navigeer naar deze directory, en maak een nieuw bestand genaamd README.md.

Solution:

$ mkdir project
$ cd ./project
$ touch ./README.md

• Maak een nieuw bestand genaamd info.txt, voeg de tekst “Dit is een informatief bestand.” toe, en toon de inhoud van het bestand.

Solution:

$ nano info.txt
$ cat info.txt

• Maak een nieuw directory genaamd backup, kopieer het bestand info.txt naar de backup-directory, en verwijder vervolgens het originele info.txt-bestand.

Solution:

$ mkdir backup
$ cp ./info.txt ./backup/info.txt
$ rm ./info.txt

Oefeningenreeks 2

• Wijzig de eigenaar van een bestand genaamd nieuwbestand.txt naar de gebruiker jezelf en de groep je eigen groep.

Solution: $ sudo chown $USER:$USER nieuwbestand.txt

• Verplaats een bestand genaamd nieuwbestand.txt naar een nieuwe locatie met de naam nieuw_bestand.txt.

Solution: $ mv nieuwbestand.txt ./some_dir/nieuw_bestand.txt

• Kopieer een bestand genaamd nieuw_bestand.txt naar een nieuwe locatie met de naam doel.txt.

Solution: $ cp nieuw_bestand.txt ./some_dir/doel.txt

• Zoek naar een softwarepakket met de naam ’neofetch'.

Solution: $ sudo apt search neofetch

• Installeer een softwarepakket genaamd ’neofetch'.

Solution: $ sudo apt install neofetch

• Verwijder een geïnstalleerd softwarepakket genaamd ’neofetch'.

Solution: $ $ sudo apt remove neofetch

• Wijzig de permissies van een bestand genaamd nieuwbestand.txt zodat de eigenaar lees-, schrijf- en uitvoerrechten heeft, en de groep en anderen alleen lees- en uitvoerrechten hebben.

Solution: $ sudo chmod 755 nieuwbestand.txt

• Voer twee commando’s na elkaar uit, ongeacht of het eerste commando succesvol is.

Solution: $ cat nieuwbestand.txt; echo "De file bestaat of niet"

• Voer een tweede commando alleen uit als het eerste commando succesvol is.

Solution: $ cat nieuwbestand.txt && echo "De file bestaat"

• Schrijf de uitvoer van een commando naar een bestand genaamd output.txt, waarbij de bestaande inhoud van het bestand wordt overschreven.

Solution: $ ls > output.txt

• Voeg de uitvoer van een commando toe aan het einde van een bestand genaamd output.txt, zonder de bestaande inhoud te verwijderen.

Solution: $ echo "Einde bestand" >> output.txt

• Zoek naar een softwarepakket genaamd curl, installeer het pakket.

Solution:

$ sudo apt search curl
$ sudo apt install curl

• Verwijder alle bestanden in je map met de extensie .txt.

Solution: $ rm *.txt

• Maak een bestand genaamd config.txt en voeg wat tekst toe. Maak een kopie van een bestand genaamd config.txt naar een nieuwe locatie met de naam backup_config.txt, wijzig de eigenaar van backup_config.txt naar de gebruiker root, en voeg de tekst “Backup voltooid” toe aan een logbestand genaamd log.txt.

Solution:

$ nano config.txt
$ cp config.txt ./backups/backup_config.txt
$ sudo chown root:root ./backups/backup_config.txt
$ touch log.txt && echo "Backup voltooid" > log.txt

Oefeningenreeks 3

Oefening 1:

• Maak een directorystructuur aan met de volgende paden: project/src, project/bin, en project/docs.
• Navigeer naar de src-directory.
• Maak een nieuw bestand genaamd main.c in de src-directory.
• Kopieer het bestand main.c naar de bin-directory.
• Toon de inhoud van de bin-directory.

Solution:

$ mkdir -p project/src project/bin project/docs
$ cd project/src
$ touch main.c
$ cp main.c ../bin/
$ ls ../bin/

Oefening 2:

• Maak een nieuwe directory genaamd backup in je thuismap.
• Maak een subdirectory genaamd 2025 in de backup-directory.
• Maak een nieuw bestand genaamd data.txt in de 2025-directory.
• Voeg de tekst “Backup data voor 2025” toe aan data.txt.
• Toon de inhoud van data.txt in de terminal.

Solution:

$ mkdir ~/backup
$ mkdir ~/backup/2025
$ touch  ~/backup/2025/data.txt
$ echo "Backup data voor 2025" > ~/backup/2025/data.txt
$ cat ~/backup/2025/data.txt

Oefening 3:

• Zoek naar een softwarepakket genaamd htop.
• Installeer het htop-pakket.
• Maak een directorystructuur aan met de volgende paden: tools/monitoring.
• Start het programma htop via het absolute pad naar de htop executable file.

Solution:

# vergeet voor het installeren van software packages geen update te doen...
$ sudo apt-get update
$ sudo apt-get install -y htop
$ mkdir -p tools/monitoring
# Een kleine zoektocht toont met dat de `htop` executable file zich bevindt in de `/bin` folder
$ /bin/htop

Oefening 4:

• Maak een directorystructuur aan met de volgende paden: website/css, website/js, en website/images.
• Navigeer naar de css-directory.
• Maak een nieuw bestand genaamd styles.css in de css-directory.
• Voeg de tekst “body { background-color: #f0f0f0; }” toe aan styles.css.
• Toon de inhoud van styles.css in de terminal.

Solution:

$ mkdir -p website/css website/js website/images
$ cd website/css
$ echo "body { background-color: #f0f0f0; }" > styles.css
$ cat styles.css

Oefening 5:

• Maak een nieuwe directory genaamd scripts in je thuismap.
• Maak een subdirectory genaamd utilities in de scripts-directory.
• Maak een nieuw shell script genaamd cleanup.sh in de utilities-directory.
• Voeg de volgende inhoud toe aan cleanup.sh:

#!/bin/bash
echo "Opruimen van tijdelijke bestanden..."
rm -rf /tmp/*
echo "Opruimen voltooid."

• Maak het script uitvoerbaar en voer het uit.

Solution:

$ mkdir -p ~/scripts/utilities
$ nano ~/scripts/utilities/cleanup.sh
$ chmod +x ~/scripts/utilities/cleanup.sh
$ ~/scripts/utilities/cleanup.sh

Oefening 6:

• Download de text file op het volgende adres https://example-files.online-convert.com/document/txt/example.txt met curl naar je home folder.

Solution: $ curl -o ~/example.txt https://example-files.online-convert.com/document/txt/example.txt

• Download het zip bestand op het volgende adres https://getsamplefiles.com/download/zip/sample-1.zip met curl naar je home folder.

Solution: $ curl -L -o ~/sample-1.zip https://getsamplefiles.com/download/zip/sample-1.zip

• Unzip dat bestand met het unzip-commando naar je home folder.

Solution: $ unzip ~/sample-1.zip -d ~/

Oefenreeks 4

Oefening 1: Maak een shell script dat aan de gebruiker een absoluut pad van een directory vraagt en het aantal .txt bestanden in die directory teruggeeft.

Solution:

#!/bin/bash

# Vraag de gebruiker om een absoluut pad van een directory
read -p "Voer het absolute pad van de directory in: " DIR_PATH

# Controleer of de directory bestaat
if [ -d "$DIR_PATH" ]; then
  COUNT=0
  # Gebruik wildcards om alle .txt files in de directory op te vragen
  for FILE in "$DIR_PATH"/*.txt; do
    # Controleer of de file bestaat
    if [ -f "$FILE" ]; then
      COUNT=$((COUNT + 1))
    # vergeet de `fi` niet
    fi
  # vergeet de `done` niet voor de for loop
  done
  echo "Aantal .txt bestanden in $DIR_PATH: $COUNT"
else
  echo "De directory $DIR_PATH bestaat niet."
fi

Oefening 2: Maak een shell script dat het ls commando nadoet met de opties -l en -a in de huidige directory. Je kan enkel de opties apart meegeven of als combinatie -la. Je hebt dus maximum 1 flag die je meegeeft aan je shell script waaruit je afleidt hoe je het ls commando moet uitvoeren.

Solution:

#!/bin/bash

if [ "$1" == "-l" ]; then
  ls -l
elif [ "$1" == "-a" ]; then
  ls -a
elif [ "$1" == "-la" ]; then
  ls -la
else
  ls
fi

Oefening 3: Maak een shell script genaamd make.sh dat 4 mogelijke opties kan meekrijgen:

• Als je de optie start meegeeft vraagt het script de gebruiker naar een projectnaam en maakt dan volgende directories aan: ./projectnaam/src en ./projectnaam/build.
• Als je de optie build meegeeft worden alle bestanden in de ./projectnaam/src directory gekopieerd naar de ./projectnaam/build directory.
• Als je de optie clean meegeeft worden alle bestanden in de ./projectnaam/build directory gewist.
• Als je de optie run meegeeft worden alle bestanden in ./projectnaam/build van alle .txt bestanden een na een getoond.

Solution:

#!/bin/bash

if [ "$1" == "start" ]; then
  echo "creating project directory ..."
  read -p "Geef een naam voor je project: " PROJECT_NAME
  mkdir -p ./$PROJECT_NAME/src ./$PROJECT_NAME/build
elif [ "$1" == "build" ]; then
  read -p "Geef je projectnaam: " PROJECT_NAME
  echo "building files to build directory ..."
  cp -r ./$PROJECT_NAME/src/* ./$PROJECT_NAME/build
elif [ "$1" == "clean" ]; then
  read -p "Geef je projectnaam: " PROJECT_NAME
  echo "cleaning build directory ..."
  rm -R ./$PROJECT_NAME/build/*
elif [ "$1" == "run" ]; then
  read -p "Geef je projectnaam: " PROJECT_NAME
  echo "running program ..."
  for FILE in ./$PROJECT_NAME/build/*.txt ; do
    if [ -f "$FILE" ]; then
      cat $FILE
    fi
  done
else
  echo "Wrong command, choose: 'start', 'build', 'clean', or 'run'."
fi
echo "Done"

VSCode

Heb je speciale tools nodig als software engineer?

Je kan in principe code schrijven puur met nano en andere command line tools, maar dat is niet altijd even handig. Hoewel nano en vergelijkbare tools lichtgewicht en eenvoudig te gebruiken zijn, missen ze veel van de geavanceerde functies die moderne ontwikkelaars nodig hebben om efficient aan software engineering te doen. Denk hierbij aan syntax highlighting, code completion, debugging, en geïntegreerde versiebeheer. Deze functies kunnen het programmeren aanzienlijk efficiënter en minder foutgevoelig maken.

Daarom bestaan er Integrated Development Environments (IDE’s) die het programmeren vergemakkelijken op verschillende manieren. IDE’s bieden een uitgebreide set tools en functies binnen één enkele applicatie. Ze ondersteunen vaak meerdere programmeertalen, bieden geavanceerde debugging-mogelijkheden en hebben ingebouwde ondersteuning voor versiebeheer zoals Git. Bovendien bieden ze vaak een visuele interface (GUI) voor het beheren van projecten en dependencies, wat het ontwikkelproces stroomlijnt.

De nadelen van IDE’s zijn echter dat ze vaak zwaar en traag kunnen zijn, vooral op oudere of minder krachtige hardware. Ze kunnen ook een steile leercurve hebben vanwege de vele functies en configuratiemogelijkheden. Dit kan overweldigend zijn voor beginners of voor ontwikkelaars die snel aan de slag willen zonder veel tijd te besteden aan het leren van een nieuwe tool.

Als je dit vergelijkt met een lichtgewicht code/text editor zoals Notepad++ of Visual Studio Code (VSCode), zie je dat deze editors een goede balans bieden tussen functionaliteit en prestaties. Ze zijn sneller en minder resource-intensief dan volledige IDE’s, maar bieden toch veel van de functies die ontwikkelaars nodig hebben.

VSCode biedt een mooie middenweg omdat je via extensies het gedrag van de editor kunt aanpassen aan je eigen wensen. Met duizenden beschikbare extensies kun je functies toevoegen zoals linting, debugging, versiebeheer, en ondersteuning voor vrijwel elke programmeertaal. Dit maakt VSCode zeer flexibel en aanpasbaar, waardoor het een populaire keuze is onder ontwikkelaars van alle niveaus.

VSCode installeren

Om Visual Studio Code (VSCode) op Windows te installeren, volg je deze stappen:

1. Ga naar de downloadpagina van Visual Studio Code en download VSCode voor Windows.
2. Vink tijdens de installatie de optie aan om VSCode aan je PATH toe te voegen tijdens de installatie en om directories te openen met VSCode.
3. Na de installatie kun je VSCode starten vanuit het Startmenu of door code in de command line te typen.

Inloggen met je Microsoft- of GitHub-account in VSCode biedt verschillende voordelen. Door in te loggen, kun je je instellingen, thema’s en extensies synchroniseren over meerdere apparaten. Dit betekent dat je dezelfde ontwikkelomgeving hebt, ongeacht waar je werkt. Bovendien kun je eenvoudig samenwerken met anderen via GitHub, waarbij je toegang hebt tot je repositories en pull requests direct vanuit VSCode. Het is echter niet verplicht.

Ingebouwde menus

VSCode komt out-of-the-box met een breed scala aan functionaliteiten die het programmeren en ontwikkelen aanzienlijk vergemakkelijken:

• Bestandenviewer: De ingebouwde bestandenviewer biedt een overzichtelijke manier om door je projectbestanden en mappen te navigeren. Je kunt eenvoudig bestanden openen, verplaatsen, hernoemen en verwijderen zonder de editor te verlaten.
• Zoekfunctie: De krachtige zoekfunctie in VSCode stelt je in staat om snel door je codebase te zoeken naar specifieke termen of patronen. Je kunt zoeken binnen een enkel bestand of door je hele project, en zelfs gebruik maken van reguliere expressies (regex) voor geavanceerde zoekopdrachten.
• Ingebouwd versiebeheer: VSCode heeft ingebouwde ondersteuning voor versiebeheer, zoals Git. Je kunt je code rechtstreeks vanuit de editor beheren, inclusief het maken van commits, het bekijken van de geschiedenis, en het oplossen van conflicten. Dit maakt het samenwerken met anderen en het bijhouden van wijzigingen in je code veel eenvoudiger.
• Debugger: De ingebouwde debugger in VSCode ondersteunt verschillende programmeertalen en biedt functies zoals breakpoints, stap-na-stap uitvoering en het inspecteren van variabelen.
• Extensies: Daarnaast kun je zoals al eerder vermeld met extensies de functionaliteit van VSCode verder uitbreiden. Of je nu ondersteuning nodig hebt voor een specifieke programmeertaal, linting, formattering, of integratie met andere tools, er is vrijwel altijd een extensie beschikbaar die aan je behoeften voldoet.
• Shortcuts: Verder kan je ook zeer gepersonaliseerde shortcuts aanmaken die bij jouw specifieke workflow passen.

Instellingen

Je kunt op verschillende niveaus instellingen aanpassen in Visual Studio Code (VSCode), wat je de flexibiliteit geeft om de editor precies naar jouw wensen te configureren. Hier zijn de belangrijkste niveaus waarop je instellingen kunt aanpassen:

• Gebruikersniveau: Instellingen die op gebruikersniveau worden aangepast, gelden voor alle projecten en werkruimten die je opent in VSCode. Deze instellingen worden opgeslagen in een JSON-bestand dat je kunt openen en bewerken via de Command Palette door te zoeken naar “Preferences: Open Settings (JSON)”.

• Workspace niveau: Instellingen op workspace niveau gelden alleen voor de specifieke werkruimte of het project dat je hebt geopend. Dit is handig als je verschillende configuraties nodig hebt voor verschillende projecten. Workspace-instellingen worden opgeslagen in een .vscode-map binnen je projectdirectory.

• Directory niveau: Binnen een werkruimte kun je ook instellingen aanpassen voor specifieke mappen. Dit kan nuttig zijn als je een project hebt met meerdere mappen die elk hun eigen configuratie vereisen.

Je kan extenties ook op die verschillende niveaus enablen/disablen.

De command pallette

De Command Palette in VSCode is een krachtige tool die je toegang geeft tot vrijwel alle functies en instellingen van de editor via een eenvoudige interface. Je kunt de Command Palette openen door Ctrl+Shift+p (Windows/Linux) of Cmd+Shift+p (Mac) te gebruiken. In de Command Palette kun je commando’s invoeren om taken uit te voeren zoals het openen van bestanden, het wijzigen van instellingen, het installeren van extensies, en nog veel meer. Het biedt een snelle manier om acties uit te voeren zonder door menu’s te hoeven navigeren, wat je workflow aanzienlijk kan versnellen. De Command Palette ondersteunt ook fuzzy search, waardoor je snel kunt vinden wat je zoekt, zelfs als je de exacte naam van het commando niet weet.

Connectie maken met WSL

Om connectie te maken met je WSL in VSCode heb je de extensie WSL nodig. Daarna kan je onderaan links op de blauwe of groene knop met >< pijlen klikken om connectie te maken met je WSL, op die manier kan je (de meeste) van je extensies behouden wanneer je connectie maakt met je wsl instantie. Je kan dan ook native de bestanden aanpassen, nieuwe bestanden/directories maken, etc. alsof vscode in de WSL omgeving zou zitten.

Enkele nuttige algemene extensies

• Prettier: Coder formatter
• TODO Tree: Hiervan gaan we in de lessen gebruik maken om oefeningen aan te geven binnen in bronbestanden.

Een ontwikkelomgeving opstellen voor de gewenste programmeertaal/het gewenste framework

Pad naar interpreter/compiler instellen:
In de instellingen kan je voor specifieke programmeertalen het pad naar de correcte interpreter of compiler instellen. Op die manier kan je ook met de play-knop code uitvoeren in VSCode

Nuttige extenties voor elk framework/elke programmeertaal:

• Syntax highlighter: Het zorgt ervoor dat verschillende elementen van de code, zoals sleutelwoorden, variabelen, strings en opmerkingen, verschillende kleuren krijgen. Dit helpt ontwikkelaars om de structuur en betekenis van de code sneller te begrijpen.
• Code suggestions/completion: ook bekend als IntelliSense, biedt intelligente code-aanvullingen terwijl je typt.
• Debugger: De ingebouwde debugger in VSCode helpt ontwikkelaars om hun code te testen en fouten op te sporen. Het biedt functies zoals breakpoints, stap-voor-stap uitvoering, en het inspecteren van variabelen. Dit versnelt de cyclus van bewerken, compileren en debuggen, waardoor ontwikkelaars efficiënter kunnen werken.
• Linter: analyseert de code op semantische en stilistische problemen. Het helpt bij het identificeren en corrigeren van subtiele programmeerfouten en coding practices die tot fouten kunnen leiden.
• Formatter: maakt de broncode gemakkelijker leesbaar door mensen door bepaalde regels en conventies af te dwingen, zoals lijnspatiëring, inspringing en spatiëring rond operators.
• Code navigation shortcuts: VSCode biedt verschillende sneltoetsen om efficiënt door je code te navigeren.
• (code templates)

Deze zijn meestal programmeertaal specifiek en moet je dus voor elke taal apart instellen. Soms kan je ook pakketten van extensies downloaden

Enkele development environments:

C development environment

Om broncode in C te runnen op je WSL ga je een aantal prerequisites nodig hebben:

• gcc: Install via sudo apt install gcc -y. De GNU Compiler Collection is een verzameling van compilers voor verschillende programmeertalen zoals C, C++, Objective-C, Fortran, Ada, en meer.
• make: Install via sudo apt install make -y. Dit is een tool die de bouw van softwareprojecten automatiseert door gebruik te maken van een Makefile om rules en dependencies te definiëren.

Verder kunnen volgende VSCode extensies handig zijn om je development proces te optimaliseren:

• C C++ Extension Pack: dit bevat volgende extensies
  • C/C++: The C/C++ extension adds language support for C/C++ to Visual Studio Code, including editing (IntelliSense) and debugging features.
  • C/C++ Themes
  • CMake Tools: CMake Tools provides the native developer a full-featured, convenient, and powerful workflow for CMake-based projects in Visual Studio Code.

Java development environment

Om Javacode te runnen en te compileren op je WSL ga je een aantal prerequisites nodig hebben:

• java: Install via sudo apt install default-jre -y. De Java Runtime Environment (JRE) is een softwarelaag die nodig is om Java-applicaties uit te voeren. Het bevat de Java Virtual Machine (JVM), kernbibliotheken en andere componenten die nodig zijn om Java-programma’s te draaien.
• javac: Install via sudo apt install default-jdk -y. De Java Development Kit (JDK) is een softwaredeveloperskit die de tools en bibliotheken bevat die nodig zijn om Java-applicaties te ontwikkelen en te compileren. Het omvat de Java Runtime Environment, een compiler (javac), en andere hulpmiddelen zoals een debugger en documentatiegenerator.
• gradle: Install via sudo snap install gradle --classic. Gradle is een open-source build automation tool die wordt gebruikt voor het ontwikkelen van softwareprojecten. Het ondersteunt het bouwen, testen, en implementeren van applicaties en is vooral populair in Java- en Android-ontwikkeling vanwege zijn flexibiliteit en krachtige configuratiemogelijkheden.
  • create gradle project in directory: gradle init
  • update gradle version per project: gradle wrapper --gradle-version x.x.x.

Verder kunnen volgende VSCode extensies handig zijn om je development proces te optimaliseren:

• Extension Pack for Java: dit bevat volgende extensies
  • Language Support for Java(TM) by Red Hat: Java Linting, Intellisense, formatting, refactoring, Maven/Gradle support and more… Java Linting, Intellisense, formatting, refactoring, Maven/Gradle support and more… Provides Java ™ language support via Eclipse ™ JDT Language Server, which utilizes Eclipse ™ JDT, M2Eclipse and Buildship.
  • Debugger for Java: A lightweight Java Debugger based on Java Debug Server which extends the Language Support for Java by Red Hat. It allows users to debug Java code using Visual Studio Code (VS Code).
  • Test Runner for Java: A lightweight extension to run and debug Java test cases in Visual Studio Code.
  • Maven for Java: Maven extension for VS Code. It provides a project explorer and shortcuts to execute Maven commands, improving user experience for Java developers who use Maven.
  • Gradle for Java: This VS Code extension provides a visual interface for your Gradle build. You can use this interface to view Gradle Tasks and Project dependencies, or run Gradle Tasks as VS Code Task. The extension also offers better Gradle file (e.g. build.gradle) authoring experience including syntax highlighting, error reporting and auto completion.
  • Project Manager for Java: A lightweight extension to provide additional Java project explorer features. It works with Language Support for Java by Red Hat.
  • IntelliCode: The Visual Studio IntelliCode extension provides AI-assisted development features for Python, TypeScript/JavaScript and Java developers in Visual Studio Code, with insights based on understanding your code context combined with machine learning.

Python development environment

Om Pythoncode te runnen (en te compileren) op je WSL ga je een aantal prerequisites nodig hebben:

• python3: Install via sudo apt install python3 -y. Het package python3 heb je nodig om Python 3 scripts en programma’s uit te voeren. Het bevat de interpreter en de standard libraries die essentieel zijn voor het draaien van Python 3 code.
• pip: Install via sudo apt-get install python3-pip. Pip is een package manager voor Python die wordt gebruikt om Python-packages te installeren en te beheren.
  • update pip via pip install --upgrade pip
• pyinstaller: Install via pip install pyinstaller (--break-system-packages). PyInstaller is een tool dat Python-scripts bundelt tot stand-alone executables voor Windows, macOS en Linux. Het maakt het mogelijk om Python-applicaties te distribueren zonder dat gebruikers een Python-omgeving hoeven te installeren.

Verder kunnen volgende VSCode extensies handig zijn om je development proces te optimaliseren:

• Python: A Visual Studio Code extension with rich support for the Python language (for all actively supported Python versions), providing access points for extensions to seamlessly integrate and offer support for IntelliSense (Pylance), debugging (Python Debugger), formatting, linting, code navigation, refactoring, variable explorer, test explorer, and more!
• Python Debugger: A Visual Studio Code extension that supports Python debugging with debugpy. Python Debugger provides a seamless debugging experience by allowing you to set breakpoints, step through code, inspect variables, and perform other essential debugging tasks. The debugpy extension offers debugging support for various types of Python applications including scripts, web applications, remote processes, and multi-threaded processes.
• Pylance: Pylance is an extension that works alongside Python in Visual Studio Code to provide performant language support. Under the hood, Pylance is powered by Pyright, Microsoft’s static type checking tool. Using Pyright, Pylance has the ability to supercharge your Python IntelliSense experience with rich type information, helping you write better code faster.

Lokaal versiebeheer: Git

Git installeren

Het versiebeheer systeem dat we in dit opleidingsonderdeel zullen gebruiken is Git. ‘Git’ staat voor Global Information Tracker of met andere woorden Git wordt gebruikt om informatie over bestanden te volgen. Via volgende link kan je alle up-to-date informatie terugvinden over hoe je Git op je besturingssysteem kan istalleren: Installatie procedure Git

Je kan checken of Git al geïnstalleerd is op je WSL door de versie ervan op te vragen via de CLI met git --version. Indien je geen error krijgt, is Git klaar voor gebruik. Als Git nog niet geïnstalleerd zou zijn kan je dit eenvoudig installeren met sudo apt install git.

Git gui en Git bash

Het is ook mogelijk een GUI voor Git te installeren, maar deze gaan we niet gebruiken. Dit is overigens ook nog niet mogelijk aangezien we enkel een CLI interface hebben voor onze WSL.

De git-gui app is een beginner vriendelijke omgeving om gemakkelijk met versiebeheer aan de slag te gaan. In de SES-lessen willen we je echter de ‘correcte’ manier aanleren om als software ontwikkelaar overweg te kunnen met verschillende handige tools zoals Git. Ook daarom gaan we de grafische interface van Git niet gebruiken.

De git workflow

(Image Src)

In Git doorloopt een bestand verschillende statussen tijdens zijn levenscyclus. Wanneer een bestand voor het eerst wordt aangemaakt, is het untracked, wat betekent dat Git het nog niet volgt. Zodra je het bestand toevoegt aan de repository met git add, wordt het staged. Dit betekent dat het klaar is om gecommit te worden. Als je het bestand daarna bewerkt, wordt het modified. Om deze wijzigingen op te nemen in de volgende commit, moet je het bestand opnieuw stagen met git add. Wanneer je tevreden bent met de wijzigingen, gebruik je git commit om de wijzigingen definitief vast te leggen (commit) in de repository. Als je een bestand niet langer nodig hebt, kun je het verwijderen met git rm, waardoor het bestand uit de repository wordt verwijderd en de status van het bestand verandert. Gedurende deze cyclus kan een bestand ook de status unmodified hebben, wat betekent dat er geen wijzigingen zijn aangebracht sinds de laatste commit.

Git correct configureren

Om van start te kunnen gaan, moeten we Git eerst nog correct configureren. Dit doen we via de volgende commando’s:

$ git config --global user.email "jouwemail@voorbeeld.com"
$ git config --global user.name "VoornaamAchternaam"

We gaan in de volgende les een account aanmaken op een cloudplatform waarmee we ons versiebeheer gaan kunnen uitbreiden met cloud opslag en de mogelijkheid om samen te werken aan hetzelfde project. Hiervoor gaan we een gratis account moeten aanmaken met een emailadres en een username. Dit moeten dezelfde worden als de gegevens die je zojuist hebt geconfigureerd. Je kan deze gegevens later nog aanpassen.

Soms ga je een text editor moeten gebruiken om bijvoorbeeld een boodschap mee te geven bij elke nieuwe ‘versie’ die we gaan opslaan. Standaard wordt hier Vim voor gebruikt, maar aangezien dit niet zo beginnersvriendelijk is, veranderen we de default liever naar iets anders zoals Nano. Dit doe je via het volgende commando:

$ git config --global core.editor nano

Een directory initialiseren als een Git directory

Om van een directory een git directory te maken en alle veranderingen beginnen tracken gebruiken we het commando:

$ git init

Er verschijnt een verborgen folder in je directory genaamd .git. In die folder zal git alles bewaren om de veranderingen te tracken en een geschiendenis van alle versies bij te houden.

Checking, staging and committing changes

Met het commando $ git status kan je controleren in welke staat alle files/directories zich bevinden. Een file/folder kan zich in één van drie toestanden bevinden:

• Modified: de file is aangepast maar nog niet gestaged.
• Staged: de file is gestaged en klaar om gecommit te worden.
• Committed: de file is sinds zijn laatste commit niet meer aangepast.
• (Untracked: dit geldt enkel voor files/folders die juist aangemaakt zijn en nog nooit gecommit werden)

Een voorbeeld output ziet er als volgt uit:

arne@LT3210121:~/gittest$ git status
On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached ..." to unstage)
        new file:   eenfile.txt

Changes not staged for commit:
  (use "git add ..." to update what will be committed)
  (use "git restore ..." to discard changes in working directory)
        modified:   eenfile.txt

Untracked files:
  (use "git add ..." to include in what will be committed)
        filetwee.txt

Met het commando $ git diff kan je de verschillen zien tussen de huidige staat van je files/folders versus de staat van de files/folders in de laatste commit.

Met het commando $ git add <filenaam> kan je afzonderlijk modified files naar de staging area ‘verplaatsen’. Volgens een goede version control strategy, is dit de manier om wijzigingen te stagen. Op die manier kan je gerichte commits maken die over een bepaald onderwerp gaan. In de praktijk wordt er soms echter voor snelheid gekozen. Zo kan je met $ git add . alle wijzigingen en nieuwe files in een keer stagen.

Met het commando $ git commit kan je alle files committen die gestaged zijn. Je teksteditor opent en je wordt gevraagd een message mee te geven met de commit. Probeer steeds een concrete boodschap mee te geven met elke commit bv. “Bug opgelost waarbij alles vetgedrukt stond”. Probeer elke commit message zo zinvol mogelijk te maken. Dit maakt het later makkelijk om terug te keren naar een belangrijke ‘versie’ van je broncode. Elke commit krijgt ook een specifieke hash zodat je gemakkelijk naar een specifieke ‘versie’ (commit) kan refereren.

• Alle modified files stagen met 1 commando: $ git add .
• Onmiddellijk een commit message meegeven binnenin het commit commando: $ git commit -m "mijn commit message"
• combinatie van de twee bovenstaande commando’s: $ git commit -a -m "mijn commit message"
  • Opgelet Met $ git commit -a worden nieuwe files niet toegevoegd. Gebruik hier dus nog $ git add voor.

Undo changes

git status geeft je ook informatie over hoe je files/folders kan unstagen en zelfs de veranderingen van files kan terugbrengen naar hoe ze eruit zagen tijdens de laatste commit. Gebruik: git rm --cached <file>... om te unstagen en git restore <file>... om wijzigingen terug te draaien (te discarden).

Bekijk de version tree (log)

Het commando $ git log wordt gebruikt om een lijst te zien van all je commits in chronologische volgorde, startend bij de laatste commit. Dat commando geeft veel informatie mee voor elke commit. Wil je liever een korter overzicht? Gebruik dan $ git log --oneline. (Met de --graph flag kan je ook de boomstructuur weergeven waar we zo dadelijk op terugkomen)

Met de flag --all kan je ervoor zorgen dat je zeker ben dat je alle branch information en tags te zien krijgt

Teruggaan naar vorige ‘versies’

Er bestaan commando’s die we kunnen gebruiken om naar een vroegere commit terug te keren. Ze werken echter op een verschillende manier en het is belangrijk dat je deze verschillen goed kent.

• $ git reset <hash van de commit>: hiermee ga je terug naar een vorige commit en worden alle commits die erna gebeurden verwijderd.
• $ git checkout <hash van de commit>: hiermee kan je tijdelijk terugkeren naar een vorige commit. Je zit hier dan in een soort virtuele omgeving waar je ook commits kan aanbrengen. Om dan terug te keren naar de HEAD van de versiegeschiedenis gebruik je:
  • $ git switch -c <branchname> : om je nieuwe virtuele commits op te slaan in een echte nieuwe branch.
  • $ git switch - : om terug te keren zonder je nieuwe virtuele commits bij te houden.

Snel een extra wijziging aanbrengen aan een vorige commit

Soms ga je snel te werk en heb je een commit gedaan, maar is er nog een kleine wijziging die eigenlijk ook nog best tot die commit hoort. In de plaats van een volledig nieuwe commit te doen kan je via git commit --amend je nieuwe gestagede files/folders toevoegen aan de laatste commit en de commit message eventueel wijzigen.

Dit is ook een handige manier om incrementeel en regelmatig een commit te doen, ook al denk je dat je werk nog geen volwaardige commit vereist. Je blijft gewoon stap na stap delen toevoegen tot je tevreden bent.

Branching

Het fijne aan Git is dat je parallel aan verschillende versies van je project kan werken door gebruik te maken van branching. Je start letterlijk een nieuwe tak waar je eigen commits kan aan toevoegen. Zo kan elk teamlid bijvoorbeeld zijn eigen branch aanmaken. Of je kan een brach aanmaken om aan een nieuwe feature te werken zonder dat je schrik moet hebben om problemen te creëren op de main branch.

Je maakt een nieuwe branch aan met het commando: $ git branch <branchnaam> Je kan de verschillende branches oplijsten met: $ git branch

• Het * symbool duidt de actieve branch aan. Je kan naar een bepaalde branch gaan met: $ git checkout <branchnaam> Je kan een branch deleten met: $ git branch -d <branchnaam>

Om een grafische voorstelling van de braches te laten printen bij het log commando gebruik je de --graph flag.

Merging

Je kan de commits van een zijtak nu terug toevoegen aan de historie van een andere tak. Dit doe je met het commando $ git merge <branchname>. Wil je bijvoorbeeld de wijzigingen van de new_feature branch mergen met de main branch, dan moet je eerst zien dat je je in de main branch bevindt en dan gebruik je het volgende commando: $ git merge new_feature

Merge conflicts

Wanneer je op twee verschillende branches echter commits heb die verschillende aanpassingen maken aan hetzelfde stukje code in je project dan ontstaat er een merge conflict. Je zal dan beide versies voorgeschoteld krijgen en jij moet dan de versie verwijderen die je niet wilt behouden. Dan pas kan de ‘merge’ succesvol afgerond worden.

.gitignore

Soms wil je dat een file niet wordt bijgehouden door git. Hier komen we in het gedeelte over remote repositories op terug. De files/folders die niet getracked mogen worden, moeten we in het bestand .gitignore toevoegen.

# Negeert het bestand secret.txt in de root directory.
/secret.txt 

# Negeert alle bestanden in de node_modules directory.
node_modules/

# Negeert de gehele directory build en alle subdirectories.
/build/

# Negeert alle bestanden met de extensie .log.
*.log 

# Negeert alle bestanden in de temp directory, maar niet de subdirectories.
/temp/*

# Negeert alle .tmp bestanden in alle directories en subdirectories.
**/*.tmp: 

# Negeert alle bestanden in de logs directory.
/logs/*
# Negeert NIET het bestand debug.log in de logs directory.
!/logs/debug.log: 

# Negeert alle bestanden die beginnen met een tilde (~).
~* 

Tagging

Om bepaalde belangrijke commits snel terug te vinden, kan je gebruik maken van tags.

• Je kan de bestaande tags oplijsten met: $ git tag
• Je kan de huidige commit taggen met bijvoorbeeld: $ git tag vX.X
• Je kan een specifieke commit taggen met bijvoorbeeld: $ git tag vX.X <hashcode commit>
• Je kan tags deleten met bijvoorbeeld: $ git tag -d vX.X

**Eens een commit een tag heeft gekregen kan je er ook naar refereren via de tag.

Indien je een bestaande tag wil verplaatsen, moet je ze eerst deleten en daarna toevoegen aan de nieuwe commit.

Belangrijk

We hebben hier enkel de basis commando’s aangehaald met een paar van de meest gebruikte manieren waarop ze gebruikt worden. Voor meer diepgang en achtergrond van alle git commando’s verwijs ik naar het Pro Git handboek. Vooral hoofdstuk 1 t.e.m. 3 zijn voor jullie interessant.

Oefeningen

1. Maak een git directory aan
2. Voeg één of meerdere tekstbestanden toe aan deze directory. Maak eventueel subfolders …
3. Gebruik $ git status om te zien wat er allemaal gecommit kan worden.
4. Commit deze veranderingen.
5. Maak aanpassingen aan de tekstbestanden en commit.
6. Keer terug naar de eerste commit via $ git reset
7. Bestudeer de output van $ git log
8. Maak een nieuwe branch en checkout naar die nieuwe branch
9. Voeg in deze branch nieuwe textbestanden toe en commit de verandering in die nieuwe branch.
10. Open File Explorer en doe een checkout terug naar de main branch. Zie je de nieuwe files verdwijnen/verschijnen wanneer je tussen de twee branches wisselt?
11. Merge je nieuwe branch met de main branch.
12. Maak veranderingen in de main branch en commit.
13. Switch terug naar je andere branch en maak op dezelfde plaats veranderingen en commit. Zo ga je een merge conflict opwekken.
14. Probeer nu weer je nieuwe branch te mergen met je main branch. Je zal eerst het merge conflict moeten oplossen
15. Tag je eerste commit met v1.0 en tag je laatste commit met v2.0.
16. Doe een git checkout naar je eerste commit door gebruik te maken van je nieuwe tags.
17. Probeer van alle bovenstaande stappen een schets te maken om zo na te gaan of je alle commando’s goed begrijpt.

Indien niet afgewerkt in het applicatiecollege, gelieve thuis af te werken tegen volgende les.

Hoe Git onder de motorkap werkt

Git behandelt een repository niet als een verzameling losse mappen en submappen met afzonderlijke geschiedenissen, maar als één ondeelbare momentopname (snapshot) van de volledige projecttoestand. Bij elke commit legt Git de complete staat van alle getrackte bestanden vast. Het is dus niet zo dat Git een specifieke map of enkel een gewijzigd bestand afzonderlijk opslaat; elke commit verwijst naar een volledige boomstructuur die het hele project representeert. Conceptueel werkt Git daarom altijd met het volledige project als één consistente eenheid.

In tegenstelling tot klassieke versiebeheersystemen slaat Git wijzigingen niet primair op als verschillen (diffs) tussen opeenvolgende versies. Hoewel Git verschillen kan berekenen en tonen wanneer dat nodig is, is het interne opslagmodel snapshot-gebaseerd. Wanneer een bestand wijzigt, wordt een nieuwe versie van de inhoud opgeslagen als een nieuw object. Ongewijzigde bestanden worden niet opnieuw gekopieerd, maar simpelweg opnieuw gerefereerd. Hierdoor kan elke commit worden gezien als een volledige projecttoestand, terwijl opslagruimte efficiënt wordt benut door hergebruik van identieke objecten.

Intern gebruikt Git een eenvoudig maar krachtig key-value opslagmodel. Alle data wordt opgeslagen als objecten die geïdentificeerd worden door een cryptografische hash van hun inhoud (traditioneel SHA-1, steeds vaker SHA-256). De hash fungeert als sleutel, de inhoud als waarde. Er zijn vier hoofdtypes objecten: blobs (bestandsinhoud), trees (mapstructuren), commits (momentopnames met metadata en verwijzingen naar een tree en eventuele ouders) en tags. Een tree-object bevat geen bestandsdata zelf, maar koppelt bestandsnamen aan blob-hashes en mapnamen aan andere tree-hashes. Op die manier vormt de volledige repositorygeschiedenis een gerichte acyclische graaf (DAG) van onveranderlijke, content-addressed objecten, waarbij elke commit via een root-tree de volledige projectstructuur definieert.

Wildcards en commando’s aaneenschakelen

Wildcards kunnen gebruikt worden om naar meerdere files tegelijk te verwijzen. Zo kan je de wildcard ‘_’ gebruiken om naar alle files die eindigen op ‘.txt’ te verwijzen.
Bijvoorbeeld: **$ git add _.txt**

Je kan commando’s ook aaneenschakelen met ‘;’ zodat meerdere commando’s onmiddellijk na elkaar uitgevoerd worden
Bijvoorbeeld: $ git add . ; git commit -m "initial commit"

Extra bronnen

• Pro Git handboek, vooral hoofdstuk 1 tot en met 3.

• git - the simple guide

• Code Forest: Git VS SVN

• the Harvard.edu guide to Git

• Beginner vriendelijke Git en Github tutorials

• Tools & Concepts for Mastering Version Control with Git

• Wil je meer inzicht in hoe git achter de schermen precies werkt? Lees dan zeker dit artikel en deze webpagina eens! Die geeft je op een toegankelijke manier uitleg over hoe git wijzigingen opslaat, wat de staging area precies is, etc. (Opmerking: het artikel begint met een vergelijking met SVN; dat is een ander/ouder versiecontrolesysteem.)

Remote repositories: Github

Types van versiebeheer systemen

Git is een gedecentraliseerd versiebeheer systeem waarbij de hele repository inclusief historiek lokaal wordt geplaatst zodra een clone commando wordt uitgevoerd. Oudere gecentraliseerde systemen zoals SVN en CVS bewaren (meta-)data op één centrale plaats: de version control server. Voor dit vak wordt resoluut voor git gekozen.

Onderstaande Figuur geeft het verschil weer tussen een gecentraliseerd versioneringssysteem, zoals SVN, CVS en MS SourceSafe, en een gedecentraliseerd systeem, zoals Git. Elke gebruiker heeft een kopie van de volledige repository op zijn lokale harde schijf staan. Bij SVN communiceren ‘working copies’ met de server. Bij Git communiceren repositories (inclusief volledige history) met eender welke andere repository. ‘Toevallig’ is dat meestal een centrale server, zoals Github.com, Gitlab.com of BitBucket.com.

(Image Src)

Andere populaire platformen zijn Gitlab, Codeberg, Gitea (self-hosted), … Deze software platformen voorzien een extra laag bovenop Git (de web UI) die het makkelijk maakt op via knoppen acties uit te voeren. Het voegt ook een social media esque aspect toe: comments, requests, issues, …

Remote repository met Github

“… GitHub is a website and cloud-based service that helps developers store and manage their code, as well as track and control changes to their code. …” source

Cloud based storage is zeer populair geworden en voor goede redenen:

• Je hebt een backup van al je data.
• Je kan op meerdere verschillende pc’s aan hetzelfde project werken zonder met een USB-stick dingen te copy pasten.
• Je kan met meerdere personen aan hetzelfde project werken zonder doorsturen van verschillende file versies via mail.

Github is zeer populair en wordt door veel softwareontwikkelaars en bedrijven gebruikt. Wij zullen dit platform dan ook gebruiken in dit opleidingsonderdeel en het is ook aangeraden dit in de toekomst voor je softwareprojecten te gebruiken.

GitHub is nu eigendom van Microsoft en is closed source software. Je kan wel de meeste features volledig gratis gebruiken. Wil je later toch liever een open source alternatief gebruiken? Dan is Gitlab een goed alternatief en werkt zeer gelijkaardig aan Github. Gitea is een goed self-hosted optie

Een account aanmaken, 2FA instellen, SSH key toevoegen

Voordat we van start kunnen gaan moeten we eerst een gratis account aanmaken. Verder moeten we ook nog een aantal belangrijke instellingen veranderen voordat we van de services gebruik kunnen maken.

Aangezien het stappenplan voor het aanmaken van een account en de gewenste instellingen wel eens kan wijzigen refereren we hieronder naar de officiële bronnen die door de ontwikkelaar up-to-date gehouden worden:

• Account aanmaken op Github (Let op! gebruik hetzelfde email adres en dezelfde username die je hebt geconfigureerd in je lokale Git om het process zo vlot mogelijk te laten verlopen)
• 2FA instellen voor je account (Let op! Verplicht sinds eind 2023)
• SSH instellen voor je account (Let op! Je kan geen contributies meer pushen naar repositories over https met enkel je username en wachtwoord)

Handige video-tutorials:

• YT - 2FA instellen voor je account
• YT - SSH instellen voor je account

Repositories clonen en veranderingen fetchen, pullen & pushen

Je kan via de webinterface van Github nieuwe repositories aanmaken. Github geeft je dan alle nodige instructies/commando’s om oftewel die remote repo te koppelen aan een bestaande lokale Git directory of een nieuwe lege repo lokaal te clonen.

Vanaf nu bestaat er een link tussen de lokale repository en de remote repository.

• Je kan nieuwe aanpassingen van je remote repository pullen naar (≈ synchroniseren met) je lokale repo met:
  • $ git pull: Dit haalt alle veranderingen binnen en past ze onmiddelijk toe
  • $ git fetch: Dit haalt alle veranderingen binnen maar zo worden nog niet gemerged met jouw lokale versie. Dit doe je met $ git merge. (git pull is dus eigenlijk een aaneenschakeling van git fetch en git merge)
• Je kan nieuwe aanpassingen van je lokale repository pushen naar je remote repo met:
  • $ git push origin: Dit pusht enkel je huidige branch.
  • $ git push origin --all: Dit pusht de wijzigingen op alle branches.
  • $ git push origin --tags: Dit pusht alle tags die nog niet aanwezig zijn op de remote repo.

Collaboration made easy

Door een teamgenoot als collaborator toe te voegen aan je remote repository kan hij/zij de repo lokaal clonen en ook wijzigingen via pushen en pullen. Door dit te combineren met branching waarbij elke collaborator bijvoorbeeld een eigen branch aanmaakt, kan je een zeer efficiënte online workflow creëren om remote te kunnen samen werken aan software projecten.
In principe kan iedereen een public remote repository clonen, maar ze gaan geen veranderingen kunnen pushen. (Hiervoor gebruik je fork en pull requests)

Collaborative workflow: to minimize merge conflicts and other problems

• Regularly pull all changes into your local directory.
• Regularly keep your branch up-to-date by merging master branch into it.
• (Merge the changes on your branch to the master branch when nessecary)
• Regularly push to remote directory.

Forking en pull requests

Je kan een public repository waar je geen collaborator van bent forken (≈ kopiëren) naar je eigen Github. Zo kan je toch nieuwe aanpassingen pushen naar ‘jouw kopie’ van de repository. Github houd echter bij vanwaar jouw fork afkomstig is. Op die manier kan je een pull request aanvragen aan de eigenaar van de originele repo. Die persoon kan jouw aanpassingen dan nakijken en toevoegen aan zijn/haar repo door de pull request te accepteren en mergen.

Een waarheidsgetrouw voorbeeld ziet er als volgt uit:

• Je wil een kleine software developer helpen door een bug op te lossen.
• Je forked de repository van de software.
• Je fixed de bug, commit en pushed de aanpassing naar jouw fork van de software repo.
• Je dient een pull request in bij de originele repo van de software.
• De eigenaar vindt jouw oplossing geweldig en merged hem met zijn eigen repo.

Op deze manier kan je zeer gemakkelijk je steentje bijdragen aan de wereld van open source software en dit maakt het principe van open source ook juist mede zo aantrekkelijk.

Oefeningen

1. Maak in je Github een repository aan voor je Git directory uit de vorige oefenreeks.
2. Koppel je lokale repo aan je remote repo en push je versiegeschiedenis naar Github.
   • Push ook je tags mee naar de remote repo en controleer of ze te zien zijn bij versions
3. Clone op een andere plaats op je computer je remote repository
4. Maak veranderingen aan de files, commit en push
5. Fetch of pull nu die veranderingen in de originele directory.
   • Denk na over het verschil tussen fetch en pull.
6. Bestudeer de online user interface van Github voor het beheren van je remote repositories
7. Voeg een medestudent toe als collaborator aan het project.
8. Laat die student je repo clonen, veranderingen aanbrenge, committen en pushen.
9. Pull nu de veranderingen van je teamgenoot in je eigen local repository
10. Laat je als collaborator verwijderen
11. Fork nu de repository van je medestudent, maak aanpassingen en submit een pull request.
12. Bestudeer nu grondig de git log van je repository. Kan je alle veranderingen volgen?
13. (Submit een issue in je eigen remote repository, los de issue op met een commit en gebruik de issuenummer met het sleutelwoord ‘Close’ (Close #<issuenummer>) om de issue automatisch op te lossen)

Extra

De Git workflow

Een typische workflow is als volgt:

1. git clone [url]: Maakt een lokale repository aan die je op Github hebt gecreëerd. Het commando maakt een subdirectory aan.
2. Doe je programmeerwerk.
3. git status en git diff: Bekijk lokale changes voordat ze naar de server gaan.
4. git add [.]: Geef aan welke changes staged worden voor commit
5. git commit -m [comment]: commit naar je lokale repository. Wijzingen moeten nu nog naar de Github server worden gesynchroniseerd.
6. git push: push lokale commits naar de Github server. Vanaf nu kan eender wie die meewerkt aan deze repository de wijzigingen downloaden op zijn lokaal systeem.
7. git pull: pull remote changes naar je lokale repository. Wijzigingen moeten altijd eerst gepushed worden voordat iemand anders kan pullen.

Ik zie niet alle branches lokaal die wel op Github staan, hoe komt dat?

Een git pull commando zal soms in de console ’new branch [branchnaam]’ afdrukken, maar toch zal je deze niet tot je beschikking hebben met het git branch commando. Dat komt omdat branches dan ook nog (lokaal) getracked moeten worden:

1. Controleer welke branch je lokaal wilt volgen met git branch -r
2. Selecteer een bepaalde branch, waarschijnlijk origin/[naam]
3. Track die branch lokaal met git branch --track [naam] origin/[naam]
4. Vanaf nu kan je ook switchen naar die branch, controleer met git branch

Merk op dat een branch verwijderen met git branch -d enkel gaat bij lokale branches. Een remote branch verwijderen wordt niet met het branch subcommando gedaan, maar met git push origin --delete [branch1] [branch2] ....

Bug tracking met Github

Enkele ‘kleine probleempjes’ in software worden al snel een hele berg aan grote problemen als er niet op tijd iets aan wordt gedaan. Bedrijven beheren deze problemen (issues) met een bug tracking systeem, waar alle door klant of collega gemeldde fouten van het systeem in worden gelogd en opgevolgd. Op die manier kan een ontwikkelaar op zoek naar werk in deze lijst de hoge prioritaire problemen identificeren, oplossen, en terug koppelen naar de melder.

graph LR;
    Bug[Bug discovery]
    Report[Bug report]
    Backlog[Bug in backlog met issues]
    Prio[Bug in behandeling]
    Fix[Bug fixed]
    Bug --> Report
    Report --> Backlog
    Backlog --> Prio
    Prio --> Fix

De inhoud van deze stappen hangt af van bedrijf tot bedrijf, maar het skelet blijft hetzelfde. Bugs worden typisch gereproduceerd door middel van unit testen op een bepaalde git branch om de bestaande ontwikkeling van nieuwe features niet in de weg te lopen. Wanneer het probleem is opgelost, wordt deze branch gemerged met de master branch:

graph LR;
    masterx[Master branch x]
    mastery[Master branch y]
    bugbranch[Create bug branch]
    bugfix[Bugfix on branch]
    masterx --> mastery
    masterx --> bugbranch
    bugbranch --> bugfix
    bugfix --> mastery

Github Issues is een minimalistische feature van Github die het mogelijk maakt om zulke bugs op te volgen. Een nieuw issue openen en een beschrijving van het probleem meegeven (samen met stappen om het te reproduceren), maakt een nieuw item aan dat standaard op ‘open’ staat. Dit kan worden toegewezen aan personen, en daarna worden ‘closed’, om aan te geven dat ofwel het probleem is opgelost, ofwel het geen echt probleem was. Issues kunnen worden gecategoriseerd door middel van labels.

Versiebeheer met je favoriete IDE

Sommige IDE’s komen met built-in tools of plug-ins om gemakkelijk gebruik te maken van Version Control en remote repositories. Ik raad je echter aan eerst voldoende te oefenen met de command line tools zodat je altijd weet wat je aan het doen bent. Op die manier ga je beter en vooral sneller problemen kunnen oplossen. Indien je de ‘hard’ way onder de knie hebt, kan je natuurlijk overschakelen naar eender welke tool jij het handigste vindt.

Github Classroom

GitHub Classroom is een hulpmiddel waarmee docenten eenvoudig programmeeropdrachten kunnen beheren en beoordelen via GitHub. Met deze tool kunnen docenten repositories aanmaken voor studenten, opdrachten automatisch toewijzen en versiebeheer integreren in het leerproces. Studenten werken in hun eigen repository, waardoor docenten de voortgang kunnen volgen en feedback kunnen geven op basis van commits en pull requests. Dit vereenvoudigt het beheer van opdrachten en stimuleert het gebruik van professionele ontwikkelpraktijken in het onderwijs.

Opdracht: zie opdrachten

Cmdline C Compiling

C programma’s compilen

Source code en header files

De ontwikkeling begint met het schrijven van de broncode in .c-bestanden en het definiëren van functies en variabelen in header files (.h-bestanden). Header files bevatten vaak declaraties van functies en macro’s die in meerdere bronbestanden worden gebruikt.

• Bijvoorbeeld main.c:

#include "header.h"
#include <stdio.h>

int main() {
    helloWorld();
    printf("Dag %s\n", naam);
    return 0;
}

• Bijvoorbeeld header.c:

#include "header.h"
#include <stdio.h>

const char* naam = "Jan";

void helloWorld() {
    printf("Hello, World!\n");
}

Preprocessor

De preprocessor voert tekstvervangingen uit voordat de daadwerkelijke compilatie begint. Dit omvat het verwerken van #include-directives, het vervangen van macro’s en het uitvoeren van voorwaardelijke compilatie.

• Bijvoorbeeld header.h:

#ifndef HEADER_H
#define HEADER_H

extern const char* naam;

void helloWorld();

#endif // HEADER_H

Compiler

De compiler vertaalt de preprocessed broncode naar assembly code. Dit is een laag-niveau representatie van de code die specifiek is voor de CPU-architectuur.

gcc -c main.c header.c

Assembler

De assembler vertaalt de assembly code naar objectbestanden (.o-bestanden). Deze objectbestanden bevatten machinecode die door de processor kan worden uitgevoerd, maar zijn nog niet zelfstandig uitvoerbaar.

Linker

De linker neemt de objectbestanden en eventuele bibliotheken en combineert deze tot een enkel uitvoerbaar bestand. De linker lost symbolen op (zoals functie- en variabelenamen) en zorgt ervoor dat alle verwijzingen correct zijn. Bijvoorbeeld:

gcc -o output.bin main.o header.o

Libraries

Libraries bevatten vooraf gecompileerde code die kan worden hergebruikt in verschillende programma’s. Er zijn statische bibliotheken (.a-bestanden) en dynamische bibliotheken (.so-bestanden). Hier komen we later bij dependency management nog op terug.

De Binary

Het eindresultaat is een binary executable die direct door het besturingssysteem kan worden uitgevoerd. Dit bestand bevat de machinecode, evenals alle benodigde symbolen en verwijzingen naar bibliotheken. Je kan je programma runnen met volgende commando:

./output.bin

Door die stappen te doorlopen, wordt de broncode omgezet in een uitvoerbaar programma dat op de doelmachine kan draaien.

De GNU Compiler Collection: gcc

GCC is een krachtige en veelzijdige compiler die wordt gebruikt voor het compileren van verschillende programmeertalen zoals C, C++, Objective-C, Fortran, Ada en meer. GCC is een essentieel onderdeel van de GNU-toolchain en wordt veel gebruikt in de open-source gemeenschap vanwege zijn flexibiliteit en robuustheid. Het biedt uitgebreide optimalisatiemogelijkheden, foutdetectie en ondersteuning voor verschillende architecturen.

• compileren naar .o files: gcc -c ./src/main.c -o ./build/main.o
• linken van de .o files: gcc -o program.bin ./build/*.o

Automatiseren met een shell script

Het handmatig compileren van bronbestanden kan tijdrovend en foutgevoelig zijn, vooral bij grotere projecten met veel bestanden. Daarom geven we de voorkeur aan het automatiseren van dit proces. Dit kan je eventueel doen met behulp van een Shell script.

Door een script te gebruiken, kunnen we ervoor zorgen dat alle stappen consistent en correct worden uitgevoerd, zonder dat we elke keer dezelfde commando’s hoeven in te typen. Dit vermindert de kans op menselijke fouten, zoals het vergeten van een bestand of het verkeerd typen van een commando. Bovendien maakt automatisering het eenvoudiger om het compilatieproces te herhalen, wat handig is bij het ontwikkelen en testen van software. Het gebruik van scripts verhoogt de efficiëntie en betrouwbaarheid van het ontwikkelproces, waardoor ontwikkelaars zich kunnen concentreren op het schrijven van code in plaats van op het compileren ervan.

Oefening

Extract alle files in dit zip bestand naar een directory naar keuze OF clone de repository. Schrijf een shell script met de naam make.sh dat de volgende dingen kan doen en plaats het in de root van je directory:

• compile: Compileert de bronbestanden naar de /build-directory en maakt de binary game.bin in de root directory
• clean: Verwijdert de binary en de object files in de build directory
• run : Voert de binary uit (bouwt eerst als die nog niet bestaat) en geeft eventuele flags door (bv --hp 12)

#!/bin/bash
# Dit script ondersteunt drie commando's:
#   compile: Compileert de bronbestanden en maakt de binary
#   run:   Voert de binary uit (bouwt eerst als die nog niet bestaat)
#   clean: Verwijdert de binary en de build directory

# Variabelen (hardcoded voor eenvoud)
SRC_DIR="src"
BUILD_DIR="build"
TARGET="game.bin"
CFLAGS="-Wall -Wextra -std=c11"

# Zorg dat er minstens één argument is meegegeven
if [ "$#" -lt 1 ]; then
    echo "Gebruik: $0 {compile|run|clean} [--hp <waarde>]"
    exit 1
fi

COMMAND=$1
# Shift the parameters so the second becomes the first etc.
shift 

if [ "$COMMAND" = "compile" ]; then
    echo "Bouwen van het project..."

    # Maak de build-directory als deze nog niet bestaat
    if [ ! -d "$BUILD_DIR" ]; then
        mkdir -p "$BUILD_DIR"
    fi

    # Compileer main.c en game.c naar objectbestanden in build/
    echo "Compileren van $SRC_DIR/main.c..."
    gcc $CFLAGS -c "$SRC_DIR/main.c" -o "$BUILD_DIR/main.o"
    echo "Compileren van $SRC_DIR/game.c..."
    gcc $CFLAGS -c "$SRC_DIR/game.c" -o "$BUILD_DIR/game.o"

    # Link de objectbestanden naar de uiteindelijke binary in de root
    echo "Linken naar $TARGET..."
    gcc $CFLAGS -o "$TARGET" "$BUILD_DIR/main.o" "$BUILD_DIR/game.o"
    echo "Build succesvol: $TARGET is aangemaakt."

elif [ "$COMMAND" = "run" ]; then
    # Bouw de binary als deze niet bestaat
    if [ ! -f "$TARGET" ]; then
        echo "Binary niet gevonden, eerst bouwen..."
        sh "$0" build "$@"
    fi
    echo "Uitvoeren van $TARGET..."
    ./"$TARGET" "$@"

elif [ "$COMMAND" = "clean" ]; then
    echo "Opruimen..."
    # Verwijder de binary en de build-directory
    rm -rf "$BUILD_DIR/*"
    rm -f "$TARGET"
    echo "Opruimen voltooid."

else
    echo "Onbekend commando: $COMMAND"
    echo "Gebruik: $0 {compile|run|clean} [--hp <waarde>]"
    exit 1
fi

Moeilijkheden

Bij het handmatig compileren van projecten kunnen er verschillende tekortkomingen optreden:

• Een van de grootste uitdagingen is het beheren van afhankelijkheden tussen bestanden. Wanneer een bronbestand wordt gewijzigd, moeten alle gerelateerde bestanden opnieuw worden gecompileerd, wat moeilijk bij te houden is zonder een gestructureerd systeem.
• Daarnaast kan het handmatig invoeren van compilatie- en linkcommando’s voor elk bestand tijdrovend en foutgevoelig zijn.
• De if-else syntax voor de verschillende opties is ook niet zo een gracieuze oplossing.

Beter, een build system: Makefiles

Makefiles proberen een antwoord te bieden op de tekortkomingen van shell scripts door een gestructureerde en efficiënte manier te bieden om afhankelijkheden en compilatiestappen te beheren. Ze maken gebruik van regels en doelen om automatisch te bepalen welke bestanden opnieuw moeten worden gecompileerd wanneer een bronbestand wordt gewijzigd. Dit voorkomt onnodige hercompilatie en bespaart tijd. Bovendien kunnen Makefiles complexe build-processen eenvoudig beheren door verschillende taken zoals compileren, linken, testen en opruimen te automatiseren. Ze bieden ook flexibiliteit door het gebruik van variabelen en conditionele statements, waardoor dezelfde Makefile kan worden gebruikt voor verschillende configuraties en platformen.

Hoe zijn makefiles opgebouwd?

Makefiles zijn opgebouwd uit een reeks regels die beschrijven hoe verschillende bestanden in een project moeten worden gecompileerd en gelinkt. Elke regel in een makefile bestaat uit drie hoofdonderdelen: doelen, afhankelijkheden en commando’s.

1. Doelen (Targets): Dit zijn de bestanden die je wilt genereren, zoals objectbestanden of een uitvoerbaar bestand. Een doel kan ook een alias zijn voor een groep commando’s, zoals all of clean.
2. Afhankelijkheden (Dependencies): Dit zijn de bestanden waarvan het doel afhankelijk is. Als een van deze bestanden wordt gewijzigd, weet make dat het doel opnieuw moet worden gegenereerd.
3. Commando’s (Commands): Dit zijn de shell-commando’s die worden uitgevoerd om het doel te genereren. Ze MOETEN beginnen met een tab en worden uitgevoerd in de volgorde waarin ze zijn geschreven.

Voorbeeld:

# Doel: objectbestand 'main.o' en 'header.o'
compile: main.c header.c
    gcc -c main.c -o main.o
    gcc -c main.c -o header.o

# Doel: uitvoerbaar bestand 'program.bin'
program: main.o header.o
    gcc -o program.bin main.o header.o

# Doel: opruimen van gecompileerde bestanden
clean:
    rm -f program.bin main.o header.o

• Het doel program hangt af van main.o en header.o. Als een van deze objectbestanden wordt gewijzigd, wordt program opnieuw gegenereerd.
• De regel compile specificeert hoe de nodige .c-bestanden moeten worden gecompileerd naar de respectievelijke .o-bestanden.
• Het doel clean verwijdert de gecompileerde bestanden, wat handig is voor een schone hercompilatie.

Syntax en Flow

Een ’naïve’ make file zou er kunnen uitzien zoals hieronder, met wat leuke syntax zoals variabelen:

# Declareer variabelen
SRCDIR = ./src
BUILDDIR = ./build

TARGET = program.bin

# Je kan zoals in de commando's simpelweg wildcards gebruiken
compile: 
	gcc -c $(SRCDIR)/header.c -o ./build/header.o
	gcc -c ./src/main.c -o ./build/main.o
	gcc -o $(TARGET) ./build/*.o

clean:
	rm -rf program.bin $(BUILDDIR)/*

# @ suppresses outputting the command to the terminal
run: 
	@echo "Running program ..." 
	./program.bin

Hiermee bereiken we echter niets meer mee dan een gewoon shell script daarom gaan we van de rule en dependecy met wat syntactische suiker om de kracht van Makefiles te unlocken:

# Declareer variabelen kan met `=`, `:=` of `::=`
CC = gcc
CFLAGS = -Wall -Wextra -std=c11
SRCDIR = ./src
BUILDDIR = ./build

# declareer alle .c files
CFILES = $(SRCDIR)/main.c $(SRCDIR)/header.c
# declareer de corresponderende .o files
OBJECTS = $(BUILDDIR)/main.o $(BUILDDIR)/header.o

TARGET = program.bin

# Het is een good practice om altijd een `all` rule te implementeren
# In dit geval is de `all` afhankelijk van onze TARGET
all: $(TARGET)

# Maar waar is onze TARGET afhankelijk van ...
# van alle object files, want enkel dan kunnen we linken tot een binary
$(TARGET): $(OBJECTS)
	$(CC) -o $@ $^
# Hierboven verwijzen we met $@ naar alles links van de `:` en met $^ alle elementen er rechts van

# Maar onze OBJECTS zijn op hun beurt weer afhankelijk van hun corresponderende .c files ...
# we gebruiken hier regular expressions waardoor % een wildcard is
$(BUILDDIR)/%.o: $(SRCDIR)/%.c
	$(CC) $(CFLAGS) -c -o $@ $<
# Hierboven verwijzen we met $@ naar alles links van de `:` en met $< (het corresponderende element) er rechts van

compile: $(TARGET)

clean: 
	rm -rf $(TARGET) $(OBJECTS)

run: $(TARGET)
	./$(TARGET)

We declareren als eerst de all-rule omdat wanneer je standaard geen command meegeeft aan make, de eerste rule uitgevoerd zal worden.

Met deze structuur zal er wanneer je make run ingeeft enkel gecompileerd worden wat gewijzigt is! Voor mog meer info kan je hier terecht

Maar we kunnen nog beter

Nu moeten we nog manueel alle source-files gaan benoemen, maar hier bestaat echter ook wat makefile ‘magic’ voor om dit te automatiseren: zie voorbeeld hieronder:

CC = gcc
CFLAGS = -Wall -Wextra -std=c11
SRCDIR = ./src
BUILDDIR = ./build

# declareer alle .c files en gebruik de * wildcard om simpelweg alle .c bestanden te selecteren in de SRCDIR
CFILES = $(wildcard $(SRCDIR)/*.c)
# declareer de corresponderende .o files via subsititutie en renaming
OBJECTS = $(patsubst $(SRCDIR)/%.c,$(BUILDDIR)/%.o,$(CFILES))

TARGET = program.bin

all: $(TARGET)

$(TARGET): $(OBJECTS)
	$(CC) -o $@ $^

$(BUILDDIR)/%.o: $(SRCDIR)/%.c
	$(CC) $(CFLAGS) -c -o $@ $<

compile: $(TARGET)

clean: 
	rm -rf $(TARGET) $(OBJECTS)

run: $(TARGET)
	./$(TARGET)

Nog steeds niet perfect maar buiten scope van deze cursus

Makefiles blijven een aantal beperkingen hebben waaronder dat wanneer je een CONSTANT in een header file aanpast, make niet noodzakelijk doorheeft dat je de file die gebruik maakt van de constant moet updaten. Dit valt op te lossen met wat ’elbow grease’ aan de make-syntax maar dat valt buiten de scope van deze cursus. Later gaan we toch ook gebruik maken van meer advanced build systems.

Oefening

1. Maak nu een Makefile voor de game van hierboven die dezelfde functionaliteit biedt als je gemaakte shell script.

# Directories
SRC_DIR = src
BUILD_DIR = build

# Doel binary
TARGET = game.bin

# Compiler en flags
CC = gcc
CFLAGS = -Wall -Wextra -std=c11

# Alle bronbestanden en objectbestanden
SRCS = $(wildcard $(SRC_DIR)/*.c)
OBJS = $(patsubst $(SRC_DIR)/%.c,$(BUILD_DIR)/%.o,$(SRCS))

# Standaard doel: bouw de binary
all: $(TARGET)

# Link de objectbestanden tot de uiteindelijke binary
$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) -o $(TARGET) $(OBJS)

# Compileer .c naar .o en plaats deze in de build map
$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c | $(BUILD_DIR)
	$(CC) $(CFLAGS) -c $< -o $@

# Zorg dat de build map bestaat
$(BUILD_DIR):
	mkdir -p $(BUILD_DIR)

# Geef ook de optie om 'compile' als een commando mee te geven
compile: $(TARGET)

# Voer de binary uit. Eventuele argumenten meegegeven met ARGS worden doorgegeven.
run: $(TARGET)
	./$(TARGET) $(ARGS)
# run as `make run ARGS="--your-flags"`

# Verwijder de binary en de build directory
clean:
	rm -f $(TARGET)
	rm -rf $(BUILD_DIR)

2. Breid de functionaliteit van je spel verder uit, door nieuwe Monsters te spawnen wanneer je een monster verslaat. Hou dan ook bij hoeveel monsters je verslagen hebt. Dat is je uitendelijke score wanneer je sterft.
   • Zoek op hoe je de library cJSON downloaden, toevoegen aan je applicatie en kan gebruiken in de main.c file.
   • Laat wanneer je sterft de applicatie de naam van de speler vragen en een JSON object aanmaken van de speler met naam en score en dit toevoegen aan een /resources/highscore.json bestand.
   • Voeg aan het begin van de game toe dat de huidige highscores van de json file geladen worden en getoond worden aan de speler.
   • (Geniet hierbij van het feit dat je een gemakkelijke makefile hebt om snel wijzigingen aan de code te testen.)
   • De cJSON-library is een voorbeeld van een dependency, we gaan hier nog dieper over in in het deel rond ‘Dependency management’

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cJSON.h"

// Function to read the JSON file
char *read_file(const char *filename)
{
  FILE *file = fopen(filename, "rb");
  if (!file)
  {
    return NULL;
  }
  fseek(file, 0, SEEK_END);
  long length = ftell(file);
  fseek(file, 0, SEEK_SET);
  char *data = (char *)malloc(length + 1);
  fread(data, 1, length, file);
  data[length] = '\0';
  fclose(file);
  return data;
}

// Function to write the JSON file
void write_file(const char *filename, const char *data)
{
  FILE *file = fopen(filename, "wb");
  if (!file)
  {
    perror("File opening failed");
    return;
  }
  fwrite(data, 1, strlen(data), file);
  fclose(file);
}

int main()
{
  const char *filename = "scores.json";

  // Read the JSON file
  char *json_data = read_file(filename);
  cJSON *root;

  if (!json_data)
  {
    // File does not exist, create a new JSON object
    root = cJSON_CreateArray();
  }
  else
  {
    // Parse the existing JSON data
    root = cJSON_Parse(json_data);
    if (!root)
    {
      printf("Error parsing JSON data\n");
      free(json_data);
      return 1;
    }
    free(json_data);
  }

  // Create a new JSON object to add
  cJSON *new_entry = cJSON_CreateObject();
  cJSON_AddStringToObject(new_entry, "name", "Jane Doe");
  cJSON_AddNumberToObject(new_entry, "score", 95);

  // Add the new entry to the JSON array
  cJSON_AddItemToArray(root, new_entry);

  // Convert JSON object to string
  char *updated_json_data = cJSON_Print(root);

  // Write the updated JSON data back to the file
  write_file(filename, updated_json_data);

  // Clean up
  cJSON_Delete(root);
  free(updated_json_data);

  return 0;
}

Interessante bronnen

• Understanding C program Compilation Process

Cmdline Java Compiling

Dit is in principe iets wat je in het INF1 vak onbewust reeds uitvoerde door op de groene “Compile” knop te drukken van je NetBeans/IntelliJ IDE. Het is belangrijk om te weten welke principes hier achter zitten net als in C. Hieronder volgt dus een kort overzicht over het compileren van Java programma’s zonder een buildtool, later gaan we hier meestal een buildtool voor gebruiken om ons leven gemakkelijk te maken.

Prerequisites

Zoals in Java development environment in VSCode kan zien heb je twee programma’s nodig:

• de Java Runtime Environment (JRE) om het commando java te gebruiken om gecompileerde Java programma’s te kunnen runnen.
• de Java Development Kit (JDK) om het commando javac te gebruiken om Java broncode (.java-files) te compileren (en verzamelen in een jar-file.)

De Java Virtual Machine (JVM)

Waarom heb je nu toch een extra stukje software nodig om Java-applicaties te runnen? In C hebben we echter gezien dat we juist willen compileren naar een binary zodat we dit native kunnen uitvoeren. Java wil namelijk een oplossing bieden voor de ‘flaw’ in hoe C-programma’s werken. Zoals daar aangehaald compileer je een C-programma naar een bepaalde architectuur, daarom kan je een C-programma dat gecompileerd is voor een x86-cpu niet runnen op een arm-cpu bijvoorbeeld. Java lost dit probleem op door te compileren naar een speciale bytecode, die dan door de Java Virtual Machine (JVM) kan worden uitgevoerd op de onderliggende architectuur. De JVM vormt dus een laag tussen je bytecode en de hardware. Op die manier moet de gebruiker enkel één programma specifiek voor zijn/haar architectuur downloaden (de JVM) en kunnen de Java-binaries hetzelfde blijven. Je hoeft dan als developer geen meerdere verschillende binaries meer te voorzien. TOP!

Een minimaal programma compileren

public class Main {

	public static void main(String[] args) {
		System.out.println("Hallo Wereld!");
	}
}

Dit programma heeft geen package en moet bewaard worden onder Main.java om de naam van de klasse te respecteren. Compileren en uitvoeren:

$ javac Main.java
$ java Main
Hallo Wereld

Het javac commando heeft vanuit Main.java een bytecode bestand aangemaakt genaamd Main.class, dat met java wordt uitgevoerd.

Verschillende bestanden compileren

Stel dat onze Main klasse een Student instantie aanmaakt en daar de naam van afdrukt. De code wordt dus als volgt:

Main.java:

import student.*;

public class Main {

	public static void main(String[] args) {
		var student = new Student("Jos");
		System.out.println("Hekyes " + student.getName());
	}
}

Student.java:

package student;

public class Student {
	private String name;
	
	public Student(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}
}

LET OP: de Student klasse leeft in package student—die op zijn beurt wordt geïmporteerd in Main.java. Dat betekent dat we Student.java moeten bewaren in de juiste subfolder ofwel package. Dit zou je moeten herkennen vanuit INF1, waar de structuur ook src/main/java/[pkg1]/[pkg2] is. We hebben nu dus twee bestanden:

java-met-cli/
├── Main.java
├── Makefile
└── student
    └── Student.java

Alle files apart compileren levert .class files op in diezelfde folders. java Main zoekt dan nog steeds de student/Student.class file vanwege de import. Dit betekent dat je je programma moeilijker kan delen met anderen: er zijn nu twee bestanden én een subdirectory met juiste naamgeving vereist.

Gelukkig kan je met de juiste argumenten alle .class files in één keer genereren en die in een aparte folder—meestal genaamd build—plaatsen:

$ javac -d ./build *.java
$ cd build
$ ls
Main.class student
$ java Main
Heykes Jos

Java programma’s packagen

Omdat het vervelend is om verschillende bestanden te kopiëren naar andere computers worden Java programma’s typisch verpakt in een .jar bestand: een veredelde .zip met metadata informatie zoals de auteur, de java versie die gebruikt werd om te compileren, welke klasse te starten (die de main() methode bevat), … Indien deze metadata, in de META-INF subfolder, niet bestaat, worden defaults aangemaakt. Zie de JDK Jar file specification voor meer informatie.

We gebruiken een derde commando, jar, om, na het compileren naar de build folder, alles te verpakkken in één kant-en-klaar programma:

$ cd build
$ jar cvf programma.jar *
added manifest
adding: Main.class(in = 957) (out= 527)(deflated 44%)
adding: student/(in = 0) (out= 0)(stored 0%)
adding: student/Student.class(in = 358) (out= 243)(deflated 32%)
$ ls
Main.class programma.jar student

Nu kunnen we programma.jar makkelijk delen. De vraag is echter: hoe voeren we dit uit, ook met java? Ja, maar met de juiste parameters, want deze moet nu IN het bestand gaan zoeken naar de juiste .class files om die bytecode uit te kunnen voeren: (In het onderstaande commando staat de -cp-flag voor Classpath. Hier geef je dus aan waar het java commando mag gaan zoeken naar .class-files naar de klasse die je wil uitvoeren)

$ java -cp "programma.jar" Main
Heykes Jos

Vanaf nu kan je programma.jar ook uploaden naar een Maven repository of gebruiken als dependency in een ander project. Merk opnieuw op dat dit handmatig aanroepen van javac in de praktijk wordt overgelaten aan de gebruikte build tool—in ons geval, gaan we dit eerst automatiseren met een Makefile.

Jar files inspecteren

Mocht je jar ooit niet goed werken kan het handig zijn om te inspecteren wat er juist allemaal in de jar-package zit. Je kan hier het volgende commando voor gebruiken: jar -tf naam.jar

Voorbeeld:

arne@LT3210121:~/ses/java-met-cli/build$ jar -tf programma.jar
META-INF/
META-INF/MANIFEST.MF
Main.class
student/
student/Student.class

Nu je de structuur ziet kan je ook makkelijk de main methode oproepen van de Student.class in de jar (als die methode zou bestaan) met java -cp "programma.jar" student.Student

Main class instellen

Merk op dat als je de jar wil runnen zonder een specifieke klasse mee te geven dan ga je nu een error krijgen in de vorm van no main manifest attribute, in programma.jar. We kunnen er wel voor zorgen dat automatisch de klasse Main gebruikt wordt. Hiervoor moeten we het attribuut Main-Class in de MANIFEST.MF file de waarde van de klassenaam meegeven (eventueel met packages ervoor).

Met het volgende commando kunnen we inspecteren hoe die MANIFEST file er nu uit ziet. unzip -q -c programma.jar META-INF/MANIFEST.MF. Voorlopig bestaat dat attribuut dus nog niet.

Met jar cvfe programma.jar Main * waar de ’e’ nu staat voor “entry point” (de Main-Class die je wilt specificeren).

Nu kan je je jar simpel runnen met java -jar programma.jar:

arne@LT3210121:~/ses/java-met-cli/build$ java -jar programma.jar
Hekyes Jos

Oefening

Extract alle files in dit zip bestand naar een directory naar keuze OF clone de repository. Schrijf een simpele makefile dat de volgende dingen kan doen en plaats het in de root van je directory:

• compile: Compileert de bronbestanden naar de /build-directory
• jar : packaged alle klassen naar een jar genaamd ‘app.jar’ in de ‘build’-directory met entrypoint de ‘App’-klasse.
• run : Voert de jar file uit
• clean: Verwijdert de ‘.class’-bestanden en het ‘.jar’-bestand uit de ‘build’-directory

MAINCLASS = App
JAR = app.jar

compile:
	@echo "compiling ..."
	javac -d ./build *.java
	@echo "Done compiling."

clean:
	@echo "cleaning ..."
	-rm -R ./build/*
	@echo "Done cleaning."

run: 
	@echo "running program $(JAR) ...\n---------------"
	@cd ./build && java -cp "$(JAR)" $(MAINCLASS)
	@echo "---------------\nProgram exited."

jar:
	@echo "Packaging to jar ..."
	cd ./build && jar cvfe $(JAR) $(MAINCLASS) *
	@echo "Done packaging."

Makefiles for Python

Interpreted vs compiled languages

In tegenstelling tot programmeertalen waarvan de broncode eerst gecompileerd moet worden om te runnen (zoals Java en C), is Python een interpreted programming language. Dit betekent dat de broncode van Python direct wordt uitgevoerd door een interpreter, zonder dat er een aparte compilatiestap nodig is. De interpreter (de python software die je geïnstalleerd moet hebben) leest de broncode regel na regel en voert deze direct uit, wat het ontwikkelproces vaak sneller en flexibeler maakt. Dit komt omdat fouten direct tijdens het uitvoeren van de code kunnen worden opgespoord en gecorrigeerd, zonder dat de hele applicatie opnieuw gecompileerd hoeft te worden.

Het verschil met compiled languages is dat bij deze talen de broncode eerst wordt omgezet in machinecode door een compiler voordat de code kan worden uitgevoerd. Dit proces, bekend als compilatie, genereert een uitvoerbaar bestand dat direct door de computer kan worden uitgevoerd. Hoewel dit een extra stap toevoegt aan het ontwikkelproces, kan het resulteren in snellere uitvoeringstijden van de uiteindelijke applicatie, omdat de machinecode direct door de hardware wordt uitgevoerd zonder tussenkomst van een interpreter.

Een tussenoplossing tussen interpreted en compiled languages is Just-In-Time (JIT) compiling. JIT-compiling combineert aspecten van beide benaderingen door de broncode tijdens de uitvoering te compileren naar machinecode. Dit betekent dat de code aanvankelijk wordt geïnterpreteerd, maar dat veelgebruikte delen van de code tijdens de uitvoering worden gecompileerd naar machinecode om de prestaties te verbeteren. Talen zoals Java en C# maken gebruik van JIT-compiling om een balans te vinden tussen de flexibiliteit van interpreted languages en de snelheid van compiled languages.

Compilen naar .bin

Iedereen kan dus in principe door het python-commando te gebruiken je python bronbestanden runnen. We willen het de eindgebruiker echter zo simpel mogelijk maken, daarom gaan we met behulp van pinstaller al onze python files kunnen “compileren” naar een single binary, dat je dan kan runnen.

Je kan pyinstaller installeren met: sudo pip install pyinstaller --break-system-packages

Je kan nu met een simpel command je python applicatie compileren naar een binary: pyinstaller --onefile --name app.bin app.py

Je ziet meteen dat pyinstaller een build/<appname>-directory aanmaakt waar pyinstaller alle files zet die nodig zijn voor de omvorming tot een binary. Een tweede belangrijke file die aangemaakt wordt is de <appname>.spec, hierin kan je verschillende eigenschappen aanpassen zoals de targeted architecture bijvoorbeeld (target_arch)

Test nu eens je binary in de ./dist-directory met ./dist/app.bin.

Oefening

Extract alle files in dit zip bestand in een directory naar keuze OF clone de repository. Schrijf een simpele makefile dat de volgende dingen kan doen en plaats het in de root van je directory:

• compile: Compileert de bronbestanden naar de single ‘monstergame.bin’ file
• clean: Verwijdert het ‘.bin’-bestand
• run : Voert de ‘monstergame.bin’ uit
• test : Voert de ‘app.py’ uit

MAIN = app.py
TARGET = app.bin

compile:
	@echo "compiling ..."
	pyinstaller --onefile --name $(TARGET) $(MAIN)
	@echo "Done compiling."

clean:
	@echo "cleaning ..."
	-rm -R ./build/*
	-rm -R ./dist/*
	@echo "Done cleaning."

test: 
	@echo "testing program $(MAIN) ...\n---------------"
	python3 $(MAIN)
	@echo "---------------\nProgram exited."

run: 
	@echo "testing program $(MAIN) ...\n---------------"
	@cd ./dist && ./$(TARGET)
	@echo "---------------\nProgram exited."

In Java (met Gradle)

Een voorbeeld

Een dependency, of afhankelijkheid, is een externe bibliotheek die wordt gebruikt tijdens de ontwikkeling van een toepassing. Tijdens het vak ‘Software ontwerp in Java’ zijn reeds de volgende externe libraries gebruikt:

1. JavaFX
2. Google Gson
3. JUnit

Het vertrouwen op zo’n library houdt in dat een extern bestand, zoals een .jar of .war bestand, gedownload en gekoppeld wordt aan de applicatie. In Java koppelen we externe libraries door middel van het CLASSPATH: dat is een lijst van folders en jars die de compiler (bij het compilen) en de Java runtime (bij het uitvoeren) gebruikt om te zoeken naar de implementatie van de gebruikte klassen.

Laten we bijvoorbeeld eens kijken naar het gebruik van de Gson library om Json te genereren vanuit Java. Serialisatie met behulp van Gson kan op deze manier:

import com.google.gson.Gson;
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
      Gson gson = new Gson();
      System.out.println(gson.toJson(Arrays.asList(1, 2, 3)));
  }
}

Als we bovenstaande Main.java compileren zonder meer, krijgen we echter de volgende fout:

arne@LT3210121:~/ses/depmanag$ javac Main.java 
Main.java:1: error: package com.google.gson does not exist
import com.google.gson.Gson;
                      ^
Main.java:6: error: cannot find symbol
      Gson gson = new Gson();
      ^
  symbol:   class Gson
  location: class Main
Main.java:6: error: cannot find symbol
      Gson gson = new Gson();
                      ^
  symbol:   class Gson
  location: class Main
3 errors

De klasse Arrays die we importeren is deel van de standaard Java-omgeving. Die zorgt dus niet voor problemen. Maar de klasse com.google.gson.Gson hebben we niet zelf gemaakt, en willen we importeren uit een library. We moeten de library daarom eerst downloaden. (Je kan de jar ook rechtstreeks downloaden met behulp van curl via $ curl https://repo1.maven.org/maven2/com/google/code/gson/gson/2.12.1/gson-2.12.1.jar --output gson-2.12.1.jar. Indien je curl nog niet geïnstalleerd hebt doe dat dan eerst!)

Het programma compileren kan nu met javac -cp gson-2.12.1.jar Main.java. We geven de gedownloade jar mee aan het classpath (via de -cp optie). Dat zorgt ervoor dat de compiler de geïmporteerde klasse Gson nu wel kan terugvinden, en het compileren slaagt.

Om het programma uit te voeren, gebruiken we java -cp "gson-2.12.1.jar:." Main. Merk op dat er nu 2 zaken aan het classpath worden meegegeven: de Google jar, maar ook de huidige directory (.) om Main.class terug te vinden.

Dit programma kan schematisch worden voorgesteld als volgt:

graph LR;
    A["Main klasse"]
    C["Gson 2.12.1"]
    A -->|depends on| C

De dependency in bovenstaand voorbeeld is gson-2.12.1.jar. Een gemiddelde Java applicatie heeft echter meer dan 10 dependencies! Het beheren van deze bestanden en de verschillende versies (major, minor, revision) geeft vaak conflicten die beter beheerd kunnen worden door tools dan door de typische vergeetachtigheid van mensen. Dit kluwen aan afhankelijkheden, dat erg snel onhandelbaar kan worden, noemt men een Dependency Hell. Er zijn varianten: DLL Hell sinds 16-bit Windows versies, RPM Hell voor Redhat Linux distributies, en JAR Hell voor Java projecten.

Zie ook xkcd’s Tech Loops rommelboeltje:

Manueel Java dependencies beheren

De eenvoudigste manier om een library te gebruiken is de volgende procedure te volgen:

1. Navigeer naar de website van de library en download de jar in een bepaalde map, zoals /lib.
2. Importeer de juiste klasses met het import statement.
3. Compileer de code door middel van het -cp lib/dependency1.jar argument.

Voor kleine programma’s met slechts enkele libraries is dit meer dan voldoende. Het kost echter redelijk veel moeite om de juiste versie te downloaden: stap 1 kost meestal meer dan 5 minuten werk.

Als er een nieuwe versie van de library verschijnt die je wil gebruiken (bv. met een nieuwe feature of een bugfix), moet je dat eerst en vooral zelf nagaan, de jar van de nieuwe versie downloaden, je classpath aanpassen, en alles opnieuw compileren. Ook bij de uitvoering moet je zorgen dat je de nieuwe versie gebruikt.

Apache Maven

Maven is een build tool van de Apache Foundation om de software te compileren en afhankelijkheden te beheren. Maven is de voorloper van Gradle en bestaat reeds 15 jaar.

Een Maven project heeft een pom.xml bestand (Project Object Model), waarin in XML formaat wordt beschreven hoe de structuur er uit ziet, welke libraries men gebruikt, en zo voort:

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mycompany.app</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0</version>
  <dependencies>
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.12.1</version>
    </dependency>
  </dependencies>
</project>

Maven is erg populair in de Java wereld, waardoor er verschillende servers zijn die deze pom bestanden samen met hun libraries beheren, zoals de Central Maven Repository en de Google Maven Repository mirrors. De syntax van het configuratiebestand is echter erg onoverzichtelijk, en er zijn ondertussen betere alternatieven beschikbaar, zoals Gradle.

We gaan in deze cursus dus geen gebruik maken van Maven, maar je zal wel verwijzingen naar de Maven repositories tegenkomen bij het gebruik van Gradle.

Gradle

Gradle is, net zoals Maven, een build tool voor de Java wereld (en daarbuiten) die de automatisatie van releasen, builden, testen, configureren, dependencies en libraries managen, … eenvoudiger maakt. Kort gezegd: het maakt het leven van een ontwikkelaar eenvoudiger.

Gradle bouwt verder op de populariteit van Maven door bijvoorbeeld compatibel te zijn met de Repository servers, maar de grootste pijnpunten wegneemt: een moeilijk leesbaar configuratiebestand in XML en complexe command-line scripts.

In een config bestand genaamd build.gradle schrijft men met Groovy, een dynamische taal bovenop de JVM (Java Virtual Machine), op een descriptieve manier hoe Gradle de applicatie moet beheren. Je build-file is dus een uitvoerbaar (Groovy) script dat gebruik maakt van Gradle-specifieke functies.

Voordelen van Gradle

De grootste voordelen van een build en dependency management tool zoals Gradle zijn onder andere:

• Een kleine voetafdruk van de broncode (repository). Het is niet nodig om zelf alle jars van libraries te downloaden en bij te houden in een lib/ folder: Gradle doet dit immers voor jou.
• Een project bootstrappen in luttele seconden: download code, voer de Gradle wrapper uit, en alles wordt vanzelf klaargezet (de juiste Gradle versie, de juiste library versies, …)
  • Een project bootstrappen betekent het opzetten of initialiseren van een project vanaf het begin, vaak met behulp van een tool of framework dat de basisstructuur en configuratie voor je genereert. Dit proces helpt je snel aan de slag te gaan zonder dat je alles handmatig hoeft in te stellen.
• Platform- en machine-onafhankelijk projecten bouwen en uitvoeren: een taak uitvoeren via een build tool op mijn PC doet exact hetzelfde als bij jou, dankzij de beschrijving van de stappen in de config file.

Om een library als Gson te kunnen gebruiken, moet je dus niet zelf de jar-bestanden aanleveren; het volstaat simpelweg om twee regels in de gradle-configuratie toe te voegen.

Gradle installeren

Je kan Gradle op je WSL installeren met het commando sudo snap install gradle --classic. (Zie ook Gradle Docs: installing manually) Dit installeert echter niet altijd de nieuwste versie van Gradle, in dit geval v7.2, maar dat is geen probleem (hier komen we zo dadelijk op terug).

Er zijn ook andere manieren om Gradle te installeren, bijvoorbeeld met SDKMAN!. Dit is een tool om allerhande (Java-gebaseerde) Software Development Kits (SDKs) op je systeem te installeren en beheren, en eenvoudig te wisselen tussen versies. Eens SDKMAN! geïnstalleerd is, kan je eenvoudig de laatste versie van gradle installeren met sdk install gradle.

Gradle in VSCode

Je kan ondersteuning toevoegen voor Gradle in VSCode met de juiste extensie, zie Java development environment in VSCode. In het bijzonder voor Gradle is de Gradle for Java plugin van Microsoft aangewezen. Deze is deel van het Extension Pack for Java, waarmee je ineens ook andere nuttige extensies voor Java-ontwikkeling installeert.

Deze extensie geeft je extra ondersteuning voor het editeren van je gradle.build bestand (syntax highlighting, code completion). Bovendien kan je voor je projecten ook de verschillende Gradle-taken bekijken en uitvoeren, alsook nagaan welke dependencies er in welke configuratie (compile, runtime, test) geactiveerd zijn — wat dat precies inhoudt, komt zodadelijk aan bod.

Een nieuw Gradle project creëren

Je kan nu een directory initialiseren als een Gradle project met gradle init. (Zie ook Gradle Docs: Bootstrapping new projects) Volg onderstaande stappen:

# Gradle vraagt eerst welk soort project je wil aanmaken, we kiezen voor 2. application
Select type of project to generate:
  1: basic
  2: application
  3: library
  4: Gradle plugin
Enter selection (default: basic) [1..4] 2

# Nu vraagt Gradle welke programmeertaal we willen gebruiken, we kiezen voor 3. Java
Select implementation language:
  1: C++
  2: Groovy
  3: Java
  4: Kotlin
  5: Scala
  6: Swift
Enter selection (default: Java) [1..6] 3

# Nu vraagt Gradle te kiezen tussen een het soort project, we kiezen voor 1. only one application project
Split functionality across multiple subprojects?:
  1: no - only one application project
  2: yes - application and library projects
Enter selection (default: no - only one application project) [1..2] 1

# Nu vraagt Gradle te kiezen tussen programmeertalen voor ons build script (de taal waarmee we onze build.gradle file gaan programmeren), we kiezen voor 1. Groovy
Select build script DSL:
  1: Groovy
  2: Kotlin
Enter selection (default: Groovy) [1..2] 1

# Nu vraagt Gradle te kiezen tussen een testframework, we kiezen voor 1. JUnit 4
Select test framework:
  1: JUnit 4
  2: TestNG
  3: Spock
  4: JUnit Jupiter
Enter selection (default: JUnit Jupiter) [1..4] 1

# Nu vraagt Gradle een projectnaam, default is dit de directorynaam. Vul niets in en druk op enter om de default te gebruiken.
Project name (default: gradletest):
# Als laatste vraagt Gradle je de naam van de source package te kiezen. Gelijkaardig als in INF 1 kiezen we voor be.ses.<app_name>
Source package (default: gradletest): be.ses.my_application

Gradle vraagt ons tijdens de init een aantal opties te kiezen. Alhoewel we in deze lessen 90% van de tijd de opties kiezen zoals hierboven getoond in het voorbeeld, kan je hieronder toch een overzicht terugvinden met enkele andere opties:

• Select type of build to generate: opties - Application - Library (gaan we niet verder op in) - Gradle Plugin (gaan we niet verder op in) - Basic
  • Application: Dit type is geconfigureerd om een volwaardige uitvoerbare applicatie te bouwen. Het bevat extra configuraties en plugins, zoals de application plugin, die helpt bij het definiëren van de hoofdmethode en het maken van uitvoerbare JAR-bestanden. Geschikt voor het ontwikkelen van volledige applicaties die je kunt uitvoeren en distribueren. (99% van de tijd gaan we dit type gebruiken)
  • Basic: Dit is een eenvoudig project zonder specifieke plugins of configuraties. Het bevat alleen de minimale structuur en bestanden die nodig zijn om een Gradle-project te starten. Je kan dan enkel nog de projectnaam kiezen en de programmeertaal voor Gradle.
• Select implementation language: Je ziet dat Gradle dus ook voor andere programmeertalen gebruikt kan worden. Wij kiezen hier echter voor Java.
• Select application structure: opties - 1. only one application project - application and library projects
  • Only one application project: Dit type project is gericht op het bouwen van één enkele applicatie. De projectstructuur is eenvoudig en bevat meestal alleen de bronbestanden en configuratiebestanden die nodig zijn om de applicatie te bouwen en uit te voeren. Geschikt voor kleinere projecten of wanneer er geen behoefte is aan herbruikbare componenten.
  • Application and library project: Dit type project is opgesplitst in meerdere modules, waaronder een applicatiemodule en een of meer bibliotheekmodules. De bibliotheekmodules bevatten herbruikbare code die door de applicatiemodule kan worden gebruikt. Deze structuur bevordert modulariteit en hergebruik van code, wat vooral nuttig is voor grotere projecten of wanneer je van plan bent om delen van je code in andere projecten te gebruiken.

gradle init \
  --type java-application \
  --dsl groovy \
  --test-framework junit \
  --project-name my_application \
  --package be.ses.my_application \
  --java-version 21 \
  --no-incubating \
  --no-split-project \
  --overwrite

Bij het aanmaken van je project maakt Gradle een aantal folders en bestanden aan. We overlopen hieronder de functionaliteit van de belangrijkste onderdelen.

Ontleding van een Gradle project mappenstructuur

Als we kijken naar de bestanden- en mappenstructuur van een voorbeeld Gradle project, vinden we dit terug:

.
├── app
│   ├── build.gradle
│   └── src
│       ├── main
│       │   ├── java
│       │   │   └── be
│       │   │       └── ses
│       │   │           └── my_application
│       │   │               └── App.java
│       │   └── resources
│       └── test
│           ├── java
│           │   └── be
│           │       └── ses
│           │           └── my_application
│           │               └── AppTest.java
│           └── resources
├── build
│   
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
└── settings.gradle

Hier onderscheiden we de volgende zaken:

1. Broncode (.java bestanden) van het app subproject in src/main/java en src/test/java, met productie- en testcode gescheiden.
2. Eventueel resources (bv. afbeeldingen, html en css voor webapplicaties …)
3. Gecompileerde code (.class bestanden) in de build/ (of ook wel out) folder.
4. Een gradle map, met daarin de Gradle-wrapper en bijhorende configuratie (hier komen we zodadelijk op terug). Deze folder hoor je toe te voegen aan je versiebeheersysteem (git).
5. Twee executables (gradlew.bat voor Windows en een gradlew-shell script voor Linux/Unix). Ook deze twee executables voeg je toe aan git.
6. Twee Gradle configuratie-bestanden:
   • settings.gradle voor het project als geheel. Hierin kan je de projectnaam aanpassen: rootProject.name = 'new_name'. Je lijst hier ook de verschillende subprojecten op: include('app').
   • build.gradle: eentje per subproject (hier enkel app). Hierin specifieer je de dependencies en andere instellingen om dat specifieke subproject te bouwen.
7. Later kan er ook een verborgen .gradle map verschijnen. De inhoud hiervan hoort niet thuis in je versiebeheersysteem!

Gradle wrapper (gradlew)

Wanneer je een Gradle project aanmaakt, creëert Gradle vanzelf ook een wrapper. Dat is een soort lokale executable in de vorm van een ./gradlew-executable (of gradlew.bat voor op Windows). Dit wrapper-script zal, wanneer het uitgevoerd wordt, een specifieke versie van Gradle downloaden in de gradle-map.

Dit heeft enkele voordelen:

• Consistentie: Het zorgt ervoor dat iedereen die aan het project werkt dezelfde versie van Gradle gebruikt, ongeacht de versie die lokaal is geïnstalleerd. (Door steeds de gradlew in de projectdirectory te gebruiken)
• Gemak: Gebruikers hoeven Gradle niet apart te installeren, omdat de wrapper automatisch de juiste versie downloadt en gebruikt. Enkel om initieel een project aan te maken heb je een lokale versie van Gradle nodig.
• Automatisering: Het maakt het eenvoudiger om build-scripts en CI/CD-pijplijnen te configureren (zie een later hoofdstuk), omdat de wrapper de benodigde Gradle-versie beheert.

De specifieke versie van Gradle die je gebruikt hangt (onder andere) af van de Java-versie die je gebruikt in je project. Hier vind je een overzicht van de minimum-versies van Gradle die compatibel zijn met welke Java-versies (JVM provided by JRE or JDK).

Eens je weet welke versie van Gradle je wil gebruiken, kan je de lokale gradlew updaten met het volgende commando: ./gradlew wrapper --gradle-version x.x (bijvoorbeeld 8.13 voor Java versies 23 of ouder).

Kijk na of je de gewenste versie gebruikt met ./gradlew --version.

distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip

Gradle laat je soms zelf ook wel weten naar welke versie je moet updaten aan de hand van je gebruikte Java code.

Bij het uitvoeren van gradlew gebeurt hetvolgende:

1. De wrapper downloadt de juiste versie van Gradle zelf (dus installatie van Gradle via snap/SDKMAN!/… is niet nodig voor een bestaand Gradle-project), afhankelijk van de specificaties in de properties file.
2. Vervolgens downloadt Gradle de juiste libraries om het project te kunnen compilen en uitvoeren.

Aan deze wrapper kan je commando’s meegeven (gradle tasks, zie later). Bijvoorbeeld, ./gradlew run om je programma (te compileren en) uit te voeren:

arne@LT3210121:~/ses/gradletest$ ./gradlew run

> Configure project :app
be.ses

> Task :app:run
Hello World!

BUILD SUCCESSFUL in 1s
2 actionable tasks: 2 executed

Dit is exact hetzelfde als in een IDE zoals IntelliJ het project runnen met de knop ‘Run’ (play-knop):

Ontleding van build.gradle

De belangrijkste file voor Gradle is de build.gradle file die zich in de ./app directory bevindt. Die ziet er als volgt:

/* This file was generated by the Gradle 'init' task.
 *
 * This generated file contains a sample Java application project to get you started.
 * For more details take a look at the 'Building Java & JVM projects' chapter in the Gradle
 * User Manual available at https://docs.gradle.org/7.2/userguide/building_java_projects.html
 */

plugins {
    // Apply the application plugin to add support for building a CLI application in Java.
    id 'application'
}

repositories {
    // Use Maven Central for resolving dependencies.
    mavenCentral()
}

dependencies {
    // Use JUnit test framework.
    testImplementation 'junit:junit:4.13.2'

    // This dependency is used by the application.
    implementation 'com.google.guava:guava:30.1.1-jre'
}

application {
    // Define the main class for the application.
    mainClass = 'be.ses.my_application.App'
}

Met de Groovy syntax definiëren we verschillende configuratie-blokken als bloknaam { ... }. We onderscheiden volgende blokken:

1. plugins: hier kan je plugins voor Gradle toevoegen, je voegt ze toe op basis van id

   • id 'application': de plugin voor Java (stand-alone) applicaties. Dit voegt taken toe zoals build en test voor je applicatie.

2. repositories: hiermee specificeer je waar de dependencies in de dependencies functie gezocht en gedownload moeten worden. Meestal gebruik je hier de default, namelijk de standaard maven central repository (ingebouwde URL).

3. dependencies: hiermee specificeer je de dependencies voor je project. Dependencies worden toegevoegd met een zogenaamde dependency configuration, die aangeeft wanneer ze nodig zijn. De meest voorkomende zijn:

   • implementation (productie dependencies): deze dependencies zijn beschikbaar bij het compileren en uitvoeren van alle code.
   • testImplementation (test dependencies): deze dependencies zijn enkel beschikbaar bij het compileren en uitvoeren van test-code.
   • runtimeOnly: deze dependencies worden enkel gebruikt bij het uitvoeren van de applicatie.

   Als argument moet je de dependency opgeven in de vorm groep:naam:versie. Je vindt deze meestal makkelijk terug op de gebruikte repository.

4. application: met mainClass = 'be.ses.my_application.App' geef je aan welke main-methode van welke klasse moet gerund worden wanneer je je applicatie wil runnen. (Dit is dus het entrypoint van je applicatie)

Dependencies toevoegen

In het kort volg je volgende procedure als je Gradle je dependencies laat beheren:

1. Zoek op de Maven Repository website naar de gewenste library.
2. Voeg één regel toe in je gradle.build bestand, in het dependencies stuk:

dependencies {
    implementation 'com.google.code.gson:gson:2.12.1'
}

Bij het uitvoeren van gradle downloadt Gradle automatisch de juiste opgegeven versie van de Gson library en gebruikt die om je applicatie te compileren en uit te voeren.

De download komt niet terecht in je project maar in een gedeelde cache-folder, zodat elke versie van een library slechts éénmaal gedownload wordt op je systeem. Die cache-folder staan in een submap van je home folder: ~/.gradle. Dit kan je controleren door ls ~/.gradle/caches/modules-2/files-2.1/, waar je nu dus ook de com.google.code.gson-directory terug vindt. Met tree ~/.gradle/caches/modules-2/files-2.1/com.google.code.gson kan je eens inspecteren hoe die directory er juist uitziet. (Indien je tree nog niet geïnstalleerd hebt doe dat dan eerst!)

arne@LT3210121:~/ses/depgradle$ tree ~/.gradle/caches/modules-2/files-2.1/com.google.code.gson
/home/arne/.gradle/caches/modules-2/files-2.1/com.google.code.gson
├── gson
│   └── 2.12.1
│       ├── 4e773a317740b83b43cfc3d652962856041697cb
│       │   └── gson-2.12.1.jar
│       └── d2c3993ff96e5da39a57e5e0b695eda560949b57
│           └── gson-2.12.1.pom
└── gson-parent
    └── 2.12.1
        └── 660107b2e76095ef86bbd15c503afe11e5260bfb
            └── gson-parent-2.12.1.pom

8 directories, 3 files

Deze cache-folder kan groeien naarmate je meer met Gradle werkt en meer versies van libraries downloadt. Je mag deze cache-folder gerust verwijderen van je systeem; de volgende keer zullen de nodige dependencies gewoon opnieuw gedownload worden.

De voordelen van het gebruik van Gradle voor dependencies zijn dus:

1. Het zoeken van libraries beperkt zich tot één centrale (Maven Repository) website, waar alle verschillende versies duidelijk worden vermeld.
2. Het downloaden van libraries beperkt zich tot één centrale locatie op je harde schijf (~/.gradle/caches/modules-2/files-2.1/): 10 verschillende Java projecten die gebruik maken van Gson vereisen linken naar dezelfde gradle bestanden. Je hebt dus geen 10 kopieën nodig van de Gson.jar.
3. Het beheren van dependencies en versies beperkt zich tot één centraal configuratiebestand: build.gradle. Dit is (terecht) een integraal deel van het project!

Lees ook: Declaring dependencies in de Gradle docs.

Transitieve dependencies

Er bestaan twee types van dependencies: directe (soms ook harde dependency genoemd) en transitieve (zachte dependency).

Een directe dependency is een afhankelijkheid die het project nodig heeft, zoals het gebruik van Gson, waarbij dit in de dependencies {} config zit.

Een transitieve of indirecte dependency is een dependency van een dependency. In een van de oefeningen hieronder maken we een project (1) aan, dat een project (2) gebruikt, dat Gson gebruikt. In project 1 is project 2 een directe dependency, en Gson een transitieve. In Project 2 is Gson een directe dependency (en komt project 1 niet voor):

graph LR;
    A[Project 1]
    B[Project 2]
    C[Gson]
    A --> B
    B --> C
    A -.-> C

Deze transitieve dependencies worden afgehandeld door Groovy. Het is niet nodig om ze toe te voegen aan je dependencies {} configuratie. Meer zelfs, als je fouten krijgt gerelateerd aan dependencies, is het geen goed idee om de zachte (transitieve) dependency (stippellijn) te veranderen in een harde, door die als directe dependency toe te voegen in de configuratie. Gradle biedt hier betere alternatieven voor.

Gradle tasks

./gradlew tasks --all voorziet een overzicht van alle beschikbare taken voor een bepaald Gradle project, opgesplitst per fase (build tasks, build setup tasks, documentation tasks, help tasks, verification tasks). Gradle plugins voorzien vaak extra tasks, zoals bijvoorbeeld de maven plugin om te publiceren naar repositories.

Belangrijke taken zijn onder andere:

• test: voer alle unit testen uit. Een rapport hiervan is beschikbaar op build/reports/tests/test/index.html. (Hier komen we zeker nog op terug in het hoofdstuk rond test-driven development)
• clean: verwijder alle binaries en metadata.
• build: compile en test het project.
• publish: (maven plugin) publiceer de gebouwde versie naar een repository.
• jar: compile en package in een jar bestand
• javadoc: (plugin) genereert HTML javadoc. Een rapport hiervan is beschikbaar op build/docs/javadoc/index.html.

Onderstaande screenshot is een voorbeeld van een Unit Test HTML rapport dat gegenereerd wordt elke keer de test task uitgevoerd wordt:

Compile to JAR

Zoals we in het hoofdstuk rond build systems in Java gezien hebben kan je alle bestanden groeperen in een .jar bestand om er een ’executable’ van te maken die door iemand anders uitgevoerd kan worden op een JVM. Om zo’n jar te maken gebruik je het commando ./gradlew jar. Er wordt dan een main_classname.jar aangemaakt in je /app/build/libs directory.

Zonder extra opties in je build.gradle wordt er echter geen 'Main-Class'-attribuut toegevoegd aan de MANIFEST file van je jar. Daarom kan je volgende optie instellen in je build.gradle waarbij application.mainClass een referentie is naar de value die je daar hebt ingesteld:

jar {
  manifest {
    attributes(
      'Main-Class': application.mainClass // dit maakt een verwijzing naar de mainClass eigenschap die je in het application {} blok hebt ingesteld
    )
  }
  archiveBaseName = 'myJarName'  // enkel als je de naam van de gegenereerde jar wil wijzigen
}

task example {
    println project.group
}

Fat jars (shadow jars)

Merk op dat een typisch project dat gebouwd of uitgevoerd wordt via Gradle geen jars van de dependencies bevat. Die worden immers automatisch door Gradle gedownload en in de juiste map (de Gradle cache) geplaatst.

Bij het maken van een jar van je applicatie zal Gradle standaard de dependencies dus niet mee in jouw jar file steken. Dat is logisch: Gradle geeft de voorkeur aan het scheiden van de applicatiecode en de dependencies. Hierdoor blijft de jar file kleiner en wordt het eenvoudiger om dependencies te beheren en bij te werken.

Wil je nu toch dat een (eind)gebruiker bijvoorbeeld niet zelf aan dependency management via Gradle moet doen, dan is het mogelijk om ook toch de applicatie en alle dependencies te bundelen in één grote jar file. Dit wordt een uber jar, fat jar, of shadow jar genoemd. De gebruiker heeft dan alles om je code uit te voeren zolang hij/zij over de juiste versie van de JVM beschikt.

Je kan Gradle zo een shadowJar laten aanmaken op deze manier:

1. Voeg de Shadow plugin toe aan je build.gradle bestand:

plugins {
    id 'java'
    id 'com.gradleup.shadow' version '8.3.0'
}

2. Configureer de plugin om een shadow jar te maken:

shadowJar {
    archiveClassifier.set('')
    mergeServiceFiles()
}

3. Bouw je project met de shadow jar taak: ./gradlew shadowJar

Hieronder zie je het verschil tussen compileren tot een shadowJar of een gewone jar:

arne@LT3210121:~/ses/depgradle/app/build/libs$ ls
app-1.0-SNAPSHOT-shadow.jar  app-1.0-SNAPSHOT.jar

# Trying to run normal jar via cli manually
arne@LT3210121:~/ses/depgradle/app/build/libs$ java -jar app-1.0-SNAPSHOT.jar 
Exception in thread "main" java.lang.NoClassDefFoundError: com/google/gson/Gson
        at be.ses.depgradle.App.main(App.java:10)
Caused by: java.lang.ClassNotFoundException: com.google.gson.Gson
        at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)
        at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
        at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:526)
        ... 1 more

# Trying to run shadowJar via cli manually
arne@LT3210121:~/ses/depgradle/app/build/libs$ java -jar app-1.0-SNAPSHOT-shadow.jar 
1

Aangezien we toch meestal gebruik gaan maken van build tools zoals Gradle die steeds zelf de nodige dependecies download en toevoegt is het gebruik van de shadowJar in deze cursus echter beperkt

Meer output

De standaard output geeft enkel weer of er iets gelukt is of niet:

Je kan meer informatie krijgen met de volgende parameters:

• --info, output LogLevel INFO. Veel irrelevante info wordt ook getoond.
• --warning-mode all, toont detail informatie van warning messages
• --stacktrace, toont de detail stacktrace bij exceptions

Repositories

Zoals eerder vermeld gebruikt Gradle Maven-repositories om de bestanden (denk: de .jar) van alle opgelijste dependencies op te halen. We bekijken hier hoe je extra repositories kan toevoegen, wat in zo’n repository zit, en hoe je zelf kan publiceren naar een repository.

Extra repositories toevoegen

Veelgebruikte libraries zijn eenvoudig te vinden via de Central Maven Repository. Wanneer echter een eigen library werd gecompileerd, die dan in andere projecten worden gebruikt, schiet deze methode tekort: interne libraries zijn uiteraard niet op een publieke server gepubliceerd.

Gradle voorziet gelukkig genoeg een eenvoudige manier om repository websites toe te voegen, met de volgende eenvoudige syntax:

repositories {
  mavenCentral()
}

mavenCentral(), jcenter(), en google() zijn ingebouwde repositories. Eigen Maven folders en URLs toevoegen kan ook. Tenslotte kan je ook een lokale folder toevoegen:

repositories {
    flatDir {
        dirs 'lib'
    }
}

Door nu de nodige .jar files toe te voegen aan de folder ./app/lib kunnen de juiste dependencies ook gevonden worden. Indien de ./app/lib directory nog niet bestaat, ga je die eerst moeten toevoegen. Deze laatste manier is vooral handig wanneer je een library (.jar) wil gebruiken die niet via een repository beschikbaar zijn. Zo kan je deze dependencies toch nog via Gradle beheren.

Een jar uit zo’n flatDir repository als dependency toevoegen doe je als volgt:

dependencies {
    implementation files('./lib/scorebord-1.0.0.jar')
}

Wat zit er in een Maven Repository

Klik op ‘View All’ bij de Gson module op de MVN Central Repo om te inspecteren welke bestanden typisch worden aangeleverd in een Maven repository:

1. De library zelf, in een bepaalde versie (gson-2.12.1.jar).
2. Eventueel de javadoc en/of sources als aparte jars (gson-2.12.1-javadoc.jar, gson-2.12.1-sources.jar).
3. Een .pom XML bestand (gson-2.12.1.pom).
4. metadata over het build-proces(gson-2.12.1.buildinfo)
5. checksums (md5 en sha1) en digitale handtekeningen (asc) op alle vorige bestanden

Het .pom XML bestand beschrijft welke afhankelijkheden deze module op zich heeft. Zo kan een hele dependency tree worden opgebouwd! Het beheren van alle afhankelijkheden is complexer dan op het eerste zicht lijkt, en laat je dus beter over aan deze gespecialiseerde tools. Google heeft voor Gson enkel Junit als test dependency aangeduid:

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Grote projecten kunnen makkelijk afhankelijk zijn van tientallen libraries, die op hun beurt weer afhankelijk zijn van meerdere andere libraries. Hieronder een voorbeeld van een dependency tree voor een typische grote webapplicatie geschreven in Java:

Je kan deze opvragen via Gradle met de de task dependencies: ./gradlew dependencies. Detailinformatie voor specifieke dependencies kunnen worden opgevraagd met de dependencyInsight task. Zie ook: Viewing and debugging dependencies in de Gradle docs.

Publiceren naar een Maven Repository

Gradle voorziet een plugin genaamd ‘maven-publish’ die bovenvermelde bestanden automatisch aanmaakt, zodat je jouw project kan uploaden naar een online repository, zoals Maven central, of een lokale maven repository. Op die manier kunnen andere projecten jouw project dan weer als dependency gaan gebruiken. Activeer de plugin en voeg een publishing block toe met de volgende eigenschappen:

plugins {
    id 'java'
    id 'maven-publish' // toevoegen!
}

group = 'be.ses'
version = '1.0-SNAPSHOT'

publishing {
    publications {
        maven(MavenPublication) {
            groupId = project.group.toString()
            version = version
            artifactId = 'projectnaam'

            from components.java
        }
    }
    repositories {
        maven {
            url = "/home/arne/local-maven-repo" // gebruik je eigen home-folder!
        }
    }
}

Indien die directory nog niet bestaat wordt deze aangemaakt!

Windows-gebruikers dienen in de url value te werken met dubbele backslashes (\\) in plaats van forward slashes (/) om naar het juiste pad te navigeren.

Deze uitbreiding voegt de target publish toe aan Gradle. Dus: ./gradlew publish publiceert de nodige bestanden in de aangegeven folder.

De aangemaakte lokale Maven repository ziet er nu zo uit:

arne@LT3210121:~/ses/depgradle$ tree /home/arne/local-maven-repo
/home/arne/local-maven-repo
└── be
    └── ses
        └── projectnaam
            ├── 1.0-SNAPSHOT
            │   ├── maven-metadata.xml
            │   ├── maven-metadata.xml.md5
            │   ├── maven-metadata.xml.sha1
            │   ├── maven-metadata.xml.sha256
            │   ├── maven-metadata.xml.sha512
            │   ├── projectnaam-1.0-20250227.143923-1.jar
            │   ├── projectnaam-1.0-20250227.143923-1.jar.md5
            │   ├── projectnaam-1.0-20250227.143923-1.jar.sha1
            │   ├── projectnaam-1.0-20250227.143923-1.jar.sha256
            │   ├── projectnaam-1.0-20250227.143923-1.jar.sha512
            │   ├── projectnaam-1.0-20250227.143923-1.module
            │   ├── projectnaam-1.0-20250227.143923-1.module.md5
            │   ├── projectnaam-1.0-20250227.143923-1.module.sha1
            │   ├── projectnaam-1.0-20250227.143923-1.module.sha256
            │   ├── projectnaam-1.0-20250227.143923-1.module.sha512
            │   ├── projectnaam-1.0-20250227.143923-1.pom
            │   ├── projectnaam-1.0-20250227.143923-1.pom.md5
            │   ├── projectnaam-1.0-20250227.143923-1.pom.sha1
            │   ├── projectnaam-1.0-20250227.143923-1.pom.sha256
            │   └── projectnaam-1.0-20250227.143923-1.pom.sha512
            ├── maven-metadata.xml
            ├── maven-metadata.xml.md5
            ├── maven-metadata.xml.sha1
            ├── maven-metadata.xml.sha256
            └── maven-metadata.xml.sha512

5 directories, 25 files

Een Gradle project dat nu gebruik wilt maken van de libraries in die lokale Maven repository dient enkel een tweede Maven repository plaats te definiëren:

repositories {
    mavenCentral()
    maven {
        url = "/home/arne/local-maven-repo" // gebruik je eigen home-folder!
    }
}

In de praktijk ga je natuurlijk eerder een gedeelde (al dan niet interne) locatie gebruiken als repository, en geen map op je eigen harde schijf. Dat laatste doet immers veel van de voordelen van het gebruik van Gradle teniet.

Oefeningen

Oefening 1: Hoger lager

1. Maak een nieuw Gradle project aan met de naam: higher_lower en gebruik de packagenaam be.ses.higher_lower.
   Hint

   Om een packagenaam in te stellen in recentere versies van gradle, moet je het --package argument meegeven: gradle init --package be.ses.higher_lower.

2. Delete de test in app/src/test/java/be/ses/higher_lower/App.java. Anders zal je je project niet kunnen runnen.
3. Aangezien we input aan de gebruiker gaan vragen moeten we een extra optie instellen in de app/build.gradle:

run {
    standardInput = System.in
}

4. Kopieer onderstaande code voor de klasse app/src/main/java/be/ses/higher_lower/App.java:

package be.ses.higher_lower;

import java.util.Random;
import java.util.Scanner;

public class App {
        public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();
        
        System.out.println("Welcome to the Higher or Lower game!");
        System.out.println("Guess if the next number will be higher or lower.");
        
        int currentNumber = random.nextInt(100) + 1;
        boolean playing = true;
        int score = 0;
        
        while (playing) {
            System.out.println("Current number: " + currentNumber);
            System.out.print("Will the next number be higher or lower? (h/l): ");
            String guess = scanner.next().toLowerCase();
            
            int nextNumber = random.nextInt(100) + 1;
            
            if ((guess.equals("h") && nextNumber > currentNumber) || 
                (guess.equals("l") && nextNumber < currentNumber)) {
                System.out.println("Correct! The next number was: " + nextNumber);
                score++;
            } else {
                System.out.println("Wrong! The next number was: " + nextNumber);
                playing = false;
            }
            
            currentNumber = nextNumber;
        }
        
        System.out.println("Game over! Your final score: " + score);
        scanner.close();
    }
}