Go-programmeren leren Training Cursus

1. Inleiding tot Go

• Wat is Go (Golang)?
• Geschiedenis en ontwerpfilosofie van Go
• Go als web- en systeemprogrammeertaal
• Kernkenmerken:
  • Statische typering
  • Eenvoud en leesbaarheid
  • Snelle compilatie
  • Ingebouwd concurrentie
  • Garbage collection
  • Cross-platform compilatie
• Gevulgebruik van Go
• Voordelen en beperkingen van Go
• Go vergeleken met C/C++, JavaScript, Ruby, Python en Java
• Het Go-ecosysteem begrijpen
• Overzicht van de Go-standaardbibliotheek
• Go-modules en het beheren van afhankelijkheden
• Anatomie van een Go-applicatie
• Praktijk: Een simpel Go-programma onderzoeken en uitvoeren

2. De Go-ontwikkelomgeving instellen

• Go installeren
• Het Go-toolchain begrijpen
• Omgevingsvariabelen configureren
• Een IDE of code-editor kiezen
• Het commandoregister met Go gebruiken
• Een Go-werkruimte aanmaken
• De projectstructuur van Go begrijpen
• Een project initialiseren met Go Modules
• go mod init gebruiken
• Afhankelijkheden beheren met go get
• Afhankelijkheden bijwerken en inspecteren
• Brontekst opmaken met gofmt
• Programma’s uitvoeren met go run
• Applicaties bouwen met go build
• Go-applicaties installeren
• Applicaties cross-compileren
• Praktijk: Een Go-project in een container aanmaken en configureren

3. Variabelen, constanten en typen in Go

• Variabelen declareren
• Expliciete versus afgeleide typen
• Korte variabeledeclaraties
• Constanten
• Nulwaarden
• Bereik en levensduur van variabelen
• Primitieve datatypen:
  • Getallen (Integers)
  • Getallen met floating point
  • Complexe getallen
  • Booleaanse waarden
  • Strings
• Conversies van typen
• Werken met Unicode en UTF-8
• Runes en bytes
• Meervoudige variabeletoe wijzing
• Typveiligheid begrijpen
• Oefening: Een klein commandoregister-programma voor gegevensverwerking bouwen

4. Operatoren en expressies

• Arithmetische operatoren
• Vergelijkingsoperatoren
• Logische operatoren
• Toewijzingsoperatoren
• Incrémenten en décémenten
• Operatorprioriteit
• Werken met berekeningen met integers en floating point
• Vermijden van veelvoorkomende fouten bij typeconversie
• Oefening: Berekeningen en validatielogica implementeren

5. Daten, tijden en opmaak

• Het pakket time gebruiken
• Datum aanmaken en manipuleren
• Huidige tijd ophalen
• Tijdzones en locaties
• Datums en tijden parsen
• Datums en tijden formateren
• Duur berekenen
• Werken met Unix-tijdstempels
• Time-outs afhandelen
• Oefening: Tijdstempels en duurberkeningen toevoegen aan een applicatie

6. Arrays, slices, maps en structs

Arrays

• Arrays declareren
• Arrays initialiseren
• Itereren over arrays
• Meervoudige arrays

Slices

• Slices versus arrays begrijpen
• Slices aanmaken
• Elementen toevoegen
• Slices kopiëren
• Lengte en capaciteit van slices
• Slices van slices
• Veelvoorkomende valkuilen bij slices

Maps

• Maps aanmaken
• Items toevoegen en verwijderen
• Controleren of een sleutel bestaat
• Itereren over maps
• Maps met complexe gegevens

Structs

• Structures definiëren

• Velden in structs

• Structs initialiseren

• Nestede structs

• Anonieme structs

• Struct-methoden

• JSON-structtags

• Praktijk: Gebruikers, producten en applicatiedata modelen met structs, slices en maps

7. Conditionele logica en loops

• if-verklaringen
• else en else if
• Variabeledeclaraties binnen condities
• for-loops
• Eindeloze loops
• Loopcondities
• break en continue
• Itereren met range
• Gevlechte loops
• switch-verklaringen
• Expressie-gebaseerde switches
• Meerdere gevallen
• Standaardgevallen
• Type-switches
• Oefening: Validatie- en verwerkingslogica van de applicatie implementeren

8. Functies

• Functies definiëren
• Functieparameters
• Teruggevallen waarden
• Meerdere teruggegeven waarden
• Genoemde teruggevallen waarden
• Variadic functies
• Anonieme functies
• Functiewaarden
• Closures
• Recursie
• Functies als argumenten doorgeven
• Functies die fouten teruggeven
• Kleine, herbruikbare functies ontwerpen
• Oefening: Bestaande code refactoreren naar herbruikbare functies

9. Pointers en geheugensconcepten

• Wat is een pointer?
• Adres-van en dereferentie-operatoren
• Pointers en functieparameters
• Pointer-ontvangers
• Pointers naar structs
• Nil-pointers
• Wanneer pointers gebruiken
• Waarde- versus referentiesemantiek
• Geheugenbeheer en garbage collection in Go begrijpen
• Veelvoorkomende pointerfouten
• Praktijk: Applicatiedata aanpassen met behulp van pointers

10. Een webapplicatie in Go bouwen

• Overzicht van de webmogelijkheden van Go
• Inleiding tot het pakket net/http
• Een HTTP-server aanmaken
• HTTP-verzoeken en antwoorden
• HTTP-methoden
• Verzoek-URL’s en queryparameters
• HTTP-headers
• HTTP-statuscodes
• Routingsfundamenten
• Handlers aanmaken
• Formdata afhandelen
• Statische bestanden serveren
• Werken met HTML-sjablonen
• Sjabloonvariabelen en besturingsstructuren
• Een webapplicatie structureren
• Praktijk: Een basis-Go-webserver bouwen

11. Een RESTful webdienst bouwen

• REST-architectuurfundamenten
• API-endpoints ontwerpen
• GET, POST, PUT, PATCH en DELETE
• Werken met JSON
• JSON encoderen en decoderen
• Verzoekvalidatie
• HTTP-statuscodes
• Foutantwoorden
• Queryparameters en padparameters
• API-antwoordstructuren
• Handlers scheiden van zakelijke logica
• Praktijk: Een CRUD REST-API bouwen

12. Go-runtime, compilatie en projectbuilds

• De Go-compiler begrijpen
• Het bouwproces van Go
• go run
• go build
• go install
• go test
• Bouwvlaggen
• Configuratie per omgeving
• Bouwen voor verschillende besturingssystemen en architecturen
• Standaardloze binaries produceren
• Applicatieconfiguratie beheren
• Oefening: De applicatie compileren voor meerdere platforms

13. Werken met bestanden en het web

• Bestanden openen en sluiten
• Bestanden lezen
• Bestanden schrijven
• Mappen aanmaken
• Bestandsmetagegevens
• Gebufferde I/O
• Werken met streams
• JSON-bestanden lezen en schrijven
• HTTP-clients
• Uitgaande HTTP-verzoeken doen
• HTTP-clientfouten afhandelen
• Time-outs en annuleringen
• API-antwoorden verwerken
• Praktijk: Gegevens ophalen vanuit een externe API en lokaal bewaren

14. Foutafhandeling en debugging

• De aanpak van Go bij fouten
• Fouten teruggeven uit functies
• Fouten controleren
• Aangepaste fouten aanmaken
• Fouten inslaan (wrapping)
• Context toevoegen aan fouten
• errors.Is en errors.As
• Panic en recovery
• Wanneer panic gebruiken
• Veelvoorkomende Go-problemen debuggen
• Activiteit van de applicatie loggen
• Go-debuggingtools gebruiken
• Oefening: Deliberate ingebrachte applicatiefouten diagnosticeren en verhelpen

15. Interfaces en abstractie

• Wat is een interface?
• Impliziete interfaceimplementatie
• Interfaces definiëren
• Interfacewaarden
• Lege interfaces / any
• Type-assertries
• Type-switches
• Pointer- versus waardeimplementaties
• Kleine interfaces ontwerpen
• Afhankelijkheidsinversie
• Interfaces gebruiken voor testing
• Koppeling van de applicatie verminderen
• Praktijk: Interfaces introduceren in de voorbeeldwebapplicatie

16. Pakketten en projectorganisatie

• Pakketten aanmaken
• Naamgevingsconventies voor pakketten
• Geëxporteerde en niet-geëxporteerde identificatoren
• Pakketten importeren
• Initialisatie van pakketten
• Applicatielaag structureren
• Interne pakketten
• Afhankelijkheden beheren met Go Modules
• Semantische versie-bepaling
• Derde-partijpakketten gebruiken
• Circulaire afhankelijkheden vermijden
• Onderhoudbare Go-projecten ontwerpen
• Oefening: De applicatie refactoreren naar aparte pakketten

17. Concurrentie met goroutines

• Wat is concurrentie?
• Goroutines
• Goroutines starten
• Lichtgewicht concurrente uitvoering begrijpen
• Synchronisatie-uitdagingen
• Gedeelde status
• Race-conditions
• sync.WaitGroup gebruiken
• Mutexes en lees/schrijf-mutexes
• Atomische operaties
• Praktijk: Een sequentiële taak omzetten naar concurrente verwerking

18. Kanalen

• Kanalen begrijpen
• Waarden verzenden en ontvangen
• Gebufferde versus ongebufferde kanalen
• Blockerend gedrag
• Kanalen sluiten
• Itereren over kanalen
• Gerichte kanalen
• Kanaalgebaseerde communicatie
• Select-verklaringen
• Time-outs en annuleringen
• Worker-pool patronen
• Producer/consumer patronen
• Praktijk: Een concurrente werkersysteem bouwen

19. Context en verzoekbeheer

• Waarom context belangrijk is in webapplicaties
• context.Context
• Verzoeksgeschikte context
• Annulering
• Doodles
• Time-outs
• Context doorgeven via applicatielaag
• Databank- of HTTP-operaties annuleren
• Misbruik van context vermijden
• Oefening: Verzoekannulering en time-outs toevoegen aan de webapplicatie

20. Go-applicaties testen

• Waarom geautomatiseerd testen belangrijk is
• Eenheden tests schrijven
• Het pakket testing
• Testfuncties
• Naamgevingsconventies voor tests
• Tabelgedreven tests
• Fouten testen
• HTTP-handlers testen
• HTTP-testservers
• Testfixtures
• Testdekking
• Benchmarks
• Voorbeeldtests
• Interfaces testen met mocks of fakes
• Praktijk: Een test-suite voor de voorbeeldapplicatie aanmaken

21. Prestatieoptimalisatie

• Prestaties van Go-applicaties begrijpen
• Flessenhalzen identificeren
• CPU versus geheugenprestaties
• Efficiënte datastructuren
• Onnodige allocaties verminderen
• Strings, bytes en buffers
• Goroutinebeheer
• Excessieve concurrentie vermijden
• Cache-strategieën
• Overwegingen voor databank en netwerk
• Applicaties profileren
• Benchmarks en prestatietests
• Profieltools van Go gebruiken
• Oefening: Een deliberet inefficiënte applicatie profileren en optimaliseren

22. Veiligheid en robuuste webapplicatiepraktijken

• Gebruikersinvoer valideren
• Veilige afhandeling van HTTP-verzoeken
• Veelvoorkomende webgevoeligheid voorkomen
• Veilige foutafhandeling
• Begrippen rond authenticatie en autorisatie
• Geheime sleutels en configuratie beheren
• Veilige HTTP-communicatie
• Vermijden van gevoelige informatie in logs
• Afhankelijkheidsbeheer en updates
• Ressourcelimieten en verzoek-time-outs
• Oefening: De voorbeeld-API beoordelen en versterken

23. Applicatielogboek en observeerbaarheid

• Fundamenten van loggen
• Gestructureerd loggen
• Logniveaus
• Verzoekloggen
• Foutloggen
• Correlatie en verzoek-ID’s
• Gedragsmonitoring van de applicatie
• Basismetrics
• Health-check endpoints
• Productieproblemen diagnosticeren
• Praktijk: Gestructureerd loggen en health-checks toevoegen

24. De Go-applicatie containerizen

• Waarom containers gebruiken?
• Go-applicaties en containerisatie
• Een Dockerfile schrijven
• Multistage builds
• Een minimale runtime-image bouwen
• Configuratie beheren via omgevingsvariabelen
• Containernetwerken
• Applicatiepoorten blootstellen
• De applicatie in een container uitvoeren
• De containeriseerde applicatie testen
• Praktijk: De voorbeeld-Go-applicatie verpakken als een productieklaar container

25. Implementatie

• Een applicatie voorbereiden voor productie
• Productiebinaries bouwen
• Omgevingsconfiguratie
• Containergebaseerde implementatie
• Implementatiearchitectuur
• Reverse proxies
• HTTPS/TLS overwegingen
• Applicatie health-checks
• Graceful shutdown
• Besturingssysteemsignalen afhandelen
• Go-webapplicaties schalen
• Horizontaal versus verticaal schalen
• Basisimplementatie-trobleeshooting
• Praktijk: De voorbeeldwebapplicatie implementeren

26. Capstone: Volledige Go-webapplicatie

Deelnemers brengen de concepten samen door een volledige applicatie te ontwikkelen.

Het project kan bevatten:

• Projectinitialisatie met Go Modules
• Pakketorganisatie
• HTTP-routing
• REST-API endpoints
• JSON-verzoeken en antwoordafhandeling
• Invoervalidatie
• Foutafhandeling
• Interfaces
• Concurrente verwerking
• Communicatie met externe APIs
• Bewaren via bestanden of databanken
• Geautomatiseerde tests
• Loggen
• Prestatieoverwegingen
• Containerisatie
• Productieconfiguratie
• Implementatie

27. Toetsing en beste praktijken

• Toetsing van de kernsyntax van Go
• Go-codeconventies
• Idiomatisch Go schrijven
• Code eenvoudig houden
• Effectief pakketontwerp
• Beste praktijken voor foutafhandeling
• Interfaceontwerpprincipes
• Beste praktijken voor concurrentie
• Teststrategieën
• Prestatieoverwegingen
• Onderhoudbaarheid en leesbaarheid
• Veelvoorkomende fouten gemaakt door nieuwe Go-ontwikkelaars
• Aanbevolen aanpak voor het voortzetten van Go-ontwikkeling

28. Conclusie

• Toetsing van kernconcepten
• Toetsing van de voltooide webapplicatie
• Vragen en discussie
• Trobleeshooting van veelvoorkomende real-world scenario’s
• Aanbevolen vervolgstappen voor Go-ontwikkeling
• Aanvullende Go-bibliotheken en ecosystemresources
• Verdere kansen voor het bouwen van productiegekeurde Go-diensten