Go-Programmierung lernen Schulung

1. Einführung in Go

• Was ist Go (Golang)?
• Geschichte und Designphilosophie von Go
• Go als Sprache für Web- und Systemprogrammierung
• Wesentliche Merkmale:
  • Statische Typisierung
  • Einfachheit und Lesbarkeit
  • Schnelle Kompilierung
  • Eingebaute Parallelität (Concurrency)
  • Garbage Collection
  • Cross-Platform-Kompilierung
• Häufige Anwendungsfälle für Go
• Vorteile und Einschränkungen von Go
• Vergleich von Go mit C/C++, JavaScript, Ruby, Python und Java
• Verständnis des Go-Ökosystems
• Überblick über die Go-Standardbibliothek
• Go-Module und Abhängigkeitsverwaltung
• Aufbau einer Go-Anwendung
• Praxis: Ein einfaches Go-Programm untersuchen und ausführen

2. Einrichtung der Go-Entwicklungsumgebung

• Installation von Go
• Verständnis der Go-Toolchain
• Konfiguration von Umgebungsvariablen
• Auswahl einer IDE oder eines Code-Editors
• Verwendung der Befehlzeile mit Go
• Anlegen eines Go-Arbeitsbereichs
• Verständnis der Go-Projektstruktur
• Initialisierung eines Projekts mit Go-Modulen
• Verwendung von go mod init
• Verwaltung von Abhängigkeiten mit go get
• Aktualisierung und Inspektion von Abhängigkeiten
• Formatierung von Quellcode mit gofmt
• Ausführen von Programmen mit go run
• Erstellen von Anwendungen mit go build
• Installation von Go-Anwendungen
• Cross-Compiling von Anwendungen
• Praxis: Ein Go-Projekt in einem Container erstellen und konfigurieren

3. Go-Variablen, Konstanten und Typen

• Deklaration von Variablen
• Explizite versus abgeleitete Typen
• Kurze Variablendeklarationen
• Konstanten
• Nullwerte
• Scope und Lebensdauer von Variablen
• Primitive Datentypen:
  • Ganzzahlen
  • Fließkommazahlen
  • Komplexe Zahlen
  • Boolesche Werte
  • Zeichenketten (Strings)
• Typkonvertierungen
• Arbeit mit Unicode und UTF-8
• Runes und Bytes
• Mehrfache Zuweisung von Variablen
• Verständnis der Typsicherheit
• Übung: Ein kleines CLI-Datenverarbeitungsprogramm erstellen

4. Operatoren und Ausdrücke

• Arithmetische Operatoren
• Vergleichsoperatoren
• Logische Operatoren
• Zuweisungsoperatoren
• Inkrement und Dekrement
• Operatorpriorität
• Arbeit mit Ganzzahl- und Fließkomma-Berechnungen
• Vermeidung häufiger Typkonvertierungsfehler
• Übung: Berechnungen und Validierungslogik implementieren

5. Datums-, Zeit- und Formatierungsfunktionen

• Verwendung des time-Pakets
• Erstellen und Manipulieren von Daten
• Abrufen der aktuellen Zeit
• Zeit zonen und Ortsangaben
• Parsen von Daten und Zeiten
• Formatierung von Daten und Zeiten
• Berechnung von Zeiträumen (Durations)
• Arbeit mit Unix-Zeitstempeln
• Handhabung von Timeouts
• Übung: Zeitstempel und Zeiträumeberechnungen zu einer Anwendung hinzufügen

6. Arrays, Slices, Maps und Structs

Arrays

• Deklaration von Arrays
• Initialisierung von Arrays
• Iteration über Arrays
• Mehrdimensionale Arrays

Slices

• Verständnis von Slices im Vergleich zu Arrays
• Erstellen von Slices
• Anhängen von Elementen
• Kopieren von Slices
• Länge und Kapazität von Slices
• Unterteilung von Slices
• Häufige Fehlerquellen bei Slices

Maps

• Erstellen von Maps
• Hinzufügen und Entfernen von Einträgen
• Prüfen, ob ein Schlüssel existiert
• Iteration über Maps
• Maps mit komplexen Daten

Structs

• Definition von Strukturen

• Felder von Structs

• Initialisierung von Structs

• Verschachtelte Structs

• Anonyme Structs

• Methoden von Structs

• JSON-Struct-Tags

• Praxis: Nutzer, Produkte und Anwendungsdaten mit Structs, Slices und Maps modellieren

7. Bedingte Logik und Schleifen

• if-Anweisungen
• else und else if
• Variablendeklarationen innerhalb von Bedingungen
• for-Schleifen
• Endlose Schleifen
• Schleifenbedingungen
• break und continue
• Iteration mit range
• Verschachtelte Schleifen
• switch-Anweisungen
• Ausdrucksbasierte Switches
• Mehrfache Fälle
• Standardfälle
• Typswitches
• Übung: Validierungs- und Verarbeitungslogik für die Anwendung implementieren

8. Funktionen

• Definition von Funktionen
• Funktionsparameter
• Rückgabewerte
• Mehrfache Rückgabewerte
• Benannte Rückgabewerte
• Variaadische Funktionen
• Anonyme Funktionen
• Funktionswerte
• Closures
• Rekursion
• Übergeben von Funktionen als Argumente
• Funktionen mit Fehler-Rückgabe
• Design kleiner, wiederverwendbarer Funktionen
• Übung: Bestehenden Code in wiederverwendbare Funktionen refaktorisieren

9. Zeiger und Konzepte zum Speicher

• Was ist ein Zeiger?
• Adressierungs- und Dereferenzierungsoperatoren
• Zeiger und Funktionsparameter
• Zeiger-Receiver
• Zeiger auf Structs
• Nil-Zeiger
• Wann Zeiger verwendet werden
• Werte- versus Referenzsemantik
• Verständnis der Speicherverwaltung und Garbage Collection in Go
• Häufige Zeigerfehler
• Praxis: Anwendungsdaten mit Zeigern modifizieren

10. Erstellung einer Webanwendung in Go

• Überblick über die Web-Fähigkeiten von Go
• Einführung in das net/http-Paket
• Erstellen eines HTTP-Servers
• HTTP-Anfragen und -Antworten
• HTTP-Methoden
• URLs und Abfrageparameter
• HTTP-Header
• HTTP-Statuscodes
• Grundlagen des Routings
• Erstellen von Handlern
• Verarbeitung von Formulardaten
• Bereitstellung statischer Dateien
• Arbeit mit HTML-Templates
• Template-Variablen und Steuerungsstrukturen
• Strukturierung einer Webanwendung
• Praxis: Ein grundlegenden Go-Webserver erstellen

11. Aufbau eines RESTful Web-Dienstes

• Grundlagen der REST-Architektur
• Design von API-Endpunkten
• GET, POST, PUT, PATCH und DELETE
• Arbeit mit JSON
• Kodieren und Dekodieren von JSON
• Validierung von Anfragen
• HTTP-Statuscodes
• Fehlerantworten
• Abfrageparameter und Pfadelemente
• API-Antwortstrukturen
• Trennung von Handlern und Business-Logik
• Praxis: Eine CRUD-REST-API erstellen

12. Go-Runtime, Kompilierung und Projektaufbau

• Verständnis des Go-Kompilers
• Der Bau-Prozess in Go
• go run
• go build
• go install
• go test
• Build-Flags
• Umgebungsspezifische Konfiguration
• Erstellung für verschiedene Betriebssysteme und Architekturen
• Erzeugung unabhängiger Binärdateien
• Verwaltung der Anwendungskonfiguration
• Übung: Die Anwendung für mehrere Plattformen kompilieren

13. Arbeit mit Dateien und dem Web

• Öffnen und Schließen von Dateien
• Lesen von Dateien
• Schreiben von Dateien
• Anlegen von Verzeichnissen
• Dateimetadaten
• Gepeffter I/O
• Arbeit mit Streams
• Lesen und Schreiben von JSON-Dateien
• HTTP-Clients
• Ausführen ausgehender HTTP-Anfragen
• Handhabung von HTTP-Client-Fehlern
• Timeouts und Abbruch
• Verarbeitung von API-Antworten
• Praxis: Daten von einer externen API abrufen und lokal persistieren

14. Fehlerbehandlung und Debugging

• Der Ansatz von Go bei Fehlern
• Rückgabe von Fehlern aus Funktionen
• Prüfung von Fehlern
• Erstellen benutzerdefinierter Fehler
• Einbetten von Fehlern (Wrapping)
• Hinzufügen von Kontext zu Fehlern
• errors.Is und errors.As
• Panic und Recovery
• Wann panic verwendet wird
• Debugging häufiger Go-Probleme
• Protokollierung der Anwendungstätigkeit
• Verwendung von Go-Debugging-Tools
• Übung: Bewusst eingeführte Anwendungsfehler diagnostizieren und beheben

15. Schnittstellen und Abstraktion

• Was ist eine Schnittstelle?
• Implizite Schnittstellenimplementierung
• Definition von Schnittstellen
• Schnittstellenwerte
• Leere Schnittstellen / any
• Typassertionen
• Typswitches
• Zeiger- versus Wert-Implementierungen
• Design kleiner Schnittstellen
• Inversion der Abhängigkeiten
• Verwendung von Schnittstellen für Tests
• Reduzierung der Kopplung der Anwendung
• Praxis: Schnittstellen in die Beispiel-Webanwendung einfügen

16. Pakete und Projektorganisation

• Erstellen von Paketen
• Namenskonventionen für Pakete
• Exportierte und nicht exportierte Bezeichner
• Importieren von Paketen
• Initialisierung von Paketen
• Organisation der Anwendungsschichten
• Interne Pakete
• Verwaltung von Abhängigkeiten mit Go-Modulen
• Semantische Versionierung
• Verwendung von Drittanbieter-Paketen
• Vermeidung zirkulärer Abhängigkeiten
• Design wartbarer Go-Projekte
• Übung: Die Anwendung in separate Pakete refaktorisieren

17. Parallelität mit Goroutines

• Was ist Parallelität (Concurrency)?
• Goroutines
• Starten von Goroutines
• Verständnis der leichten parallelen Ausführung
• Synchronisationsherausforderungen
• Gemeinsam genutzter Zustand (Shared State)
• Race Conditions
• Verwendung von sync.WaitGroup
• Mutexes und Read/Write-Mutexes
• Atomare Operationen
• Praxis: Eine sequenzielle Aufgabe in parallele Verarbeitung umwandeln

18. Kanäle (Channels)

• Verständnis von Kanälen
• Senden und Empfangen von Werten
• Puffernde versus nicht puffernde Kanäle
• Blockierendes Verhalten
• Schließen von Kanälen
• Ranging über Kanäle
• Richtungsgebundene Kanäle
• Kanalbasierte Kommunikation
• Select-Anweisungen
• Timeouts und Abbruch
• Worker-Pool-Muster
• Producer/Consumer-Muster
• Praxis: Ein paralleles Worker-System erstellen

19. Kontexte und Anfrageverwaltung

• Warum Kontexte in Webanwendungen wichtig sind
• context.Context
• Anfrage-spezifischer Kontext
• Abbruch (Cancellation)
• Fristen (Deadlines)
• Timeouts
• Propagation des Kontexts durch Anwendungsschichten
• Abbruch von Datenbank- oder HTTP-Operationen
• Vermeidung falscher Kontextnutzung
• Übung: Anfrageabbruch und Timeouts zur Webanwendung hinzufügen

20. Testen von Go-Anwendungen

• Warum automatisiertes Testen wichtig ist
• Schreiben von Unit-Tests
• Das testing-Paket
• Testfunktionen
• Namenskonventionen für Tests
• Tabelle-getriebene Tests
• Testen von Fehlern
• Testen von HTTP-Handler
• HTTP-Testserver
• Test-Fixtures
• Testabdeckung (Coverage)
• Benchmarks
• Beispieltests
• Testen von Schnittstellen mit Mocks oder Fakes
• Praxis: Eine Testsuite für die Beispielanwendung erstellen

21. Leistungsoptimierung

• Verständnis der Leistung von Go-Anwendungen
• Identifikation von Engpässen
• CPU- versus Speicherverhalten
• Effiziente Datenstrukturen
• Reduzierung unnötiger Allokationen
• Strings, Bytes und Puffer
• Goroutine-Verwaltung
• Vermeidung übermäßiger Parallelität
• Caching-Strategien
• Betrachtungen zu Datenbank und Netzwerk
• Profiling von Anwendungen
• Benchmarks und Leistungstests
• Verwendung der Profiling-Tools von Go
• Übung: Eine absichtlich ineffiziente Anwendung profilieren und optimieren

22. Sicherheit und robuste Praxisen für Webanwendungen

• Validierung von Benutzereingaben
• Sichere Handhabung von HTTP-Anfragen
• Verhütung häufiger Web-Sicherheitslücken
• Sichere Fehlerbehandlung
• Begriffe der Authentifizierung und Autorisierung
• Verwaltung von Geheimnissen und Konfiguration
• Sichere HTTP-Kommunikation
• Vermeidung sensibler Informationen in Logs
• Abhängigkeitsverwaltung und Aktualisierungen
• Ressourcenlimits und Anfrage-Timeouts
• Übung: Die Beispiel-API überprüfen und härten

23. Anwendungs-Logging und Observabilität

• Grundlagen des Loggings
• Strukturiertes Logging
• Log-Ebenen
• Anfrage-Logging
• Fehler-Logging
• Korrelation und Anfrage-IDs
• Überwachung des Anwendungsverhaltens
• Grundlegende Metriken
• Health-Check-Endpunkte
• Diagnose von Produktionsproblemen
• Praxis: Strukturiertes Logging und Health Checks hinzufügen

24. Containerisierung der Go-Anwendung

• Warum Container verwendet werden
• Go-Anwendungen und Containerisierung
• Schreiben einer Dockerfile
• Mehrfache Build-Stufen
• Erstellung eines minimalen Runtime-Images
• Verwaltung der Konfiguration über Umgebungsvariablen
• Container-Netzwerken
• Offenlegen von Anwendungsports
• Ausführen der Anwendung in einem Container
• Testen der containerisierten Anwendung
• Praxis: Die Beispiel-Go-Anwendung als produktionsreifer Container packen

25. Deployment

• Vorbereitung einer Anwendung für die Produktion
• Erstellung produktionsreifer Binärdateien
• Umgebungskonfiguration
• Container-basiertes Deployment
• Deployment-Architektur
• Reverse Proxies
• Betrachtungen zu HTTPS/TLS
• Health Checks der Anwendung
• Graceful Shutdown
• Handhabung von Betriebssystem-Signalen
• Skalierung von Go-Webanwendungen
• Horizontale versus vertikale Skalierung
• Grundlegendes Troubleshooting beim Deployment
• Praxis: Die Beispiel-Webanwendung deployen

26. Capstone: Komplettierende Go-Webanwendung

Die Teilnehmenden bringen die Konzepte zusammen, indem sie eine vollständige Anwendung entwickeln.

Das Projekt kann Folgendes enthalten:

• Projektinitialisierung mit Go-Modulen
• Paketorganisation
• HTTP-Routing
• REST-API-Endpunkte
• JSON-Anfr- und Antwortverarbeitung
• Eingabvalidierung
• Fehlerbehandlung
• Schnittstellen
• Parallele Verarbeitung
• Kommunikation mit externen APIs
• Datei- oder Datenbankpersistenz
• Automatisierte Tests
• Logging
• Leistungsbetrachtungen
• Containerisierung
• Produktionskonfiguration
• Deployment

27. Überprüfung und Best Practices

• Überprüfung der Kern-Syntax von Go
• Go-Coding-Konventionen
• Schreiben von idiomatischem Go
• Code einfach halten
• Effektives Paketdesign
• Best Practices für die Fehlerbehandlung
• Designprinzipien für Schnittstellen
• Best Practices für Parallelität
• Teststrategien
• Leistungsbetrachtungen
• Wartbarkeit und Lesbarkeit
• Häufige Fehler neuer Go-Entwickler
• Empfohlene Ansätze zur Fortsetzung der Go-Entwicklung

28. Schlussfolgerung

• Überprüfung der Schlüsselkonzepte
• Überprüfung der abgeschlossenen Webanwendung
• Fragen und Diskussion
• Troubleshooting häufiger realer Szenarien
• Empfohlene nächste Schritte für die Go-Entwicklung
• Zusätzliche Go-Bibliotheken und Ökosystem-Ressourcen
• Weitere Möglichkeiten für den Aufbau von produktionsreifen Go-Diensten