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

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

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. 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.