Programmierung in Go lernen Schulung

1. Einführung in Go

• Was ist Go (Golang)?
• Geschichte und Designphilosophie von Go
• Go als Programmiersprache für Web- und Systementwicklung
• Wesentliche Merkmale:
  • Statische Typisierung
  • Einfachheit und Lesbarkeit
  • Schnelle Kompilierung
  • Eingebaute Konkurrenz
  • Garbage Collection
  • Cross-Plattform-Kompilierung
• Häufige Anwendungsfälle für Go
• Vorteile und Einschränkungen von Go
• Go im Vergleich mit C/C++, JavaScript, Ruby, Python und Java
• Verständnis des Go-Ökosystems
• Überblick über die Go-Standardbibliothek
• Go-Module und Abhängigkeitsverwaltung
• Anatomie 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 Kommandozeile mit Go
• Anlegen eines Go-Arbeitsbereichs
• Verständnis der Go-Projektstruktur
• Initialisierung eines Projekts mit Go Modules
• Verwendung von go mod init
• Verwaltung von Abhängigkeiten mit go get
• Aktualisieren und Überprüfen von Abhängigkeiten
• Formatierung des Quellcodes mit gofmt
• Ausführen von Programmen mit go run
• Aufbau von Anwendungen mit go build
• Installation von Go-Anwendungen
• Cross-Kompilierung von Anwendungen
• Praxis: Ein Go-Projekt innerhalb eines Containers erstellen und konfigurieren

3. Go-Variablen, Konstanten und Typen

• Deklaration von Variablen
• Explizite und abgeleitete Typen
• Kurzdeklaration von Variablen
• Konstanten
• Nullwerte (Zero values)
• Gültigkeitsbereich und Lebensdauer von Variablen
• Primitive Datentypen:
  • Ganzzahlige Zahlen
  • Gleitkommazahlen
  • Komplexe Zahlen
  • Boolesche Werte
  • Zeichenketten
• Typumwandlungen
• Arbeiten mit Unicode und UTF-8
• Runes und Bytes
• Zuweisung mehrerer Variablen
• Verständnis der Typsicherheit
• Übung: Aufbau eines kleinen Programms zur Datenverarbeitung in der Kommandozeile

4. Operatoren und Ausdrücke

• Arithmetische Operatoren
• Vergleichsoperatoren
• Logische Operatoren
• Zuweisungsoperatoren
• Inkrement und Dekrement
• Operatorenpräzedenz
• Arbeiten mit Ganzzahl- und Gleitkomma-Berechnungen
• Vermeidung häufiger Typumwandlungsfehler
• Übung: Implementierung von Berechnungs- und Validierungslayouts

5. Daten, Uhrzeiten und Formatierung

• Verwendung des time-Pakets
• Erstellen und Manipulieren von Datumsangaben
• Abrufen der aktuellen Uhrzeit
• Zeitzones und Standorte
• Parsen von Daten und Uhrzeiten
• Formatierung von Daten und Uhrzeiten
• Berechnung von Zeitspannen (Durations)
• Arbeiten mit Unix-Zeitstempeln
• Umgang mit Timeouts
• Übung: Hinzufügen von Zeitstempeln und Zeitspannenberechnungen zu einer Anwendung

6. Arrays, Slices, Maps und Structs

Arrays

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

Slices

• Unterschied zwischen Slices und Arrays
• Erstellen von Slices
• Hinzufügen von Elementen
• Kopieren von Slices
• Länge und Kapazität von Slices
• Teilen von Slices (Slicing)
• Häufige Fehlerquellen bei Slices

Maps

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

Structs

• Definition von Strukturen

• Felder von Structs

• Initialisierung von Structs

• Nested Structs (verschachtelte Strukturen)

• Anonyme Structs

• Methoden von Structs

• JSON-Struktur-Tags

• Praxis: Modellieren von Nutzern, Produkten und Anwendungsdaten unter Verwendung von Structs, Slices und Maps

7. Konditionale Logik und Schleifen

• if-Aussagen
• else und else if
• Variablendeklarationen innerhalb von Bedingungen
• for-Schleifen
• Endlose Schleifen
• Schleifenbedingungen
• break und continue
• Iterieren mit range
• Verschachtelte Schleifen
• switch-Aussagen
• Ausdrucksbasierte Switch-Anweisungen
• Mehrere Fälle
• Standardfälle (Default)
• Typ-Switches
• Übung: Implementierung von Validierungs- und Verarbeitungslogik der Anwendung

8. Funktionen

• Definition von Funktionen
• Funktionsparameter
• Rückgabewerte
• Mehrere Rückgabewerte
• Benannte Rückgabewerte
• Vararg-Funktionen (Variadic)
• Anonyme Funktionen
• Funktionswerte
• Closures
• Rekursion
• Übergeben von Funktionen als Argumente
• Funktionen mit Fehler-Rückgabe
• Gestaltung kleiner, wiederverwendbarer Funktionen
• Übung: Refactoring von vorhandenem Code in wiederverwendbare Funktionen

9. Zeiger und Konzepte zum Speicher

• Was ist ein Zeiger?
• Adressierungs- und Dereferenzierungsoperatoren
• Zeiger und Funktionsparameter
• Zeiger-Receiver (Pointer receivers)
• Zeiger auf Structs
• Nil-Zeiger
• Wann Zeiger verwendet werden
• Werte- versus Referenzsemantik
• Verständnis des Speicher- und Garbage-Collection-Managements in Go
• Häufige Zeigerfehler
• Praxis: Ändern von Anwendungsdaten unter Verwendung von Zeigern

10. Erstellung einer Webanwendung in Go

• Überblick über die Web-Fähigkeiten von Go
• Einführung in das net/http-Paket
• Erstellung eines HTTP-Servers
• HTTP-Anfragen und -Antworten
• HTTP-Methoden
• Anfrage-URLs und Abfrageparameter
• HTTP-Header
• HTTP-Statuscodes
• Grundlagen der Routing
• Erstellen von Handler
• Verarbeitung von Formulardaten
• Bereitstellung statischer Dateien
• Arbeiten mit HTML-Vorlagen
• Template-Variablen und Steuerungsstrukturen
• Strukturierung einer Webanwendung
• Praxis: Aufbau eines grundlegenden Go-Web-Servers

11. Aufbau eines RESTful Web-Dienstes

• Grundlagen der REST-Architektur
• Design von API-Endpunkten
• GET, POST, PUT, PATCH und DELETE
• Arbeiten mit JSON
• Kodierung und Dekodierung von JSON
• Validierung von Anfragen
• HTTP-Statuscodes
• Fehlerantworten
• Abfrageparameter und Pfadparameter
• API-Antwortstrukturen
• Trennung von Handler und Geschäftslogik
• Praxis: Aufbau einer CRUD-REST-API

12. Go Runtime, Kompilierung und Projekt- Builds

• Verständnis des Go-Compilers
• Der Build-Prozess von Go
• go run
• go build
• go install
• go test
• Build-Flags
• Umgebungsspezifische Konfiguration
• Aufbau für verschiedene Betriebssysteme und Architekturen
• Erstellung eigenständiger Binärdateien
• Verwaltung der Anwendungskonfiguration
• Übung: Kompilierung der Anwendung für mehrere Plattformen

13. Arbeiten mit Dateien und dem Web

• Öffnen und Schließen von Dateien
• Lesen von Dateien
• Schreiben von Dateien
• Erstellen von Verzeichnissen
• Datei-Metadaten
• Pufferisiertes I/O (E/A)
• Arbeiten mit Streams
• Lesen und Schreiben von JSON-Dateien
• HTTP-Clients
• Ausführen ausgehender HTTP-Anfragen
• Umgang mit HTTP-Client-Fehlern
• Timeouts und Abbruch
• Verarbeitung von API-Antworten
• Praxis: Abrufen von Daten von einer externen API und lokale Persistierung

14. Fehlerbehandlung und Debugging

• Der Go-Ansatz für Fehler
• 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-Problemstellen
• Protokollieren der Anwendungstätigkeit (Logging)
• Verwendung von Go-Debugging-Tools
• Übung: Diagnose und Behebung absichtlich eingeführter Anwendungsfehler

15. Interfaces und Abstraktion

• Was ist eine Interface?
• Implizite Implementierung von Interfaces
• Definition von Interfaces
• Interface-Werte
• Leere Interfaces / any
• Typbehauptungen (Type assertions)
• Typ-Switches
• Implementierung über Zeiger versus Werte
• Gestaltung kleiner Interfaces
• Umkehr der Abhängigkeit (Dependency inversion)
• Verwendung von Interfaces zum Testen
• Reduzierung der Kopplung der Anwendung
• Praxis: Einführung von Interfaces in die Beispiel-Webanwendung

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 Modules
• Semantische Versionierung
• Verwendung von Drittanbieterpaketen
• Vermeidung zirkulärer Abhängigkeiten
• Gestaltung wartbarer Go-Projekte
• Übung: Refactoring der Anwendung in separate Pakete

17. Konkurrenz mit Goroutines

• Was ist Konkurrenz?
• Goroutines
• Starten von Goroutines
• Verständnis der leichten parallelen Ausführung
• Herausforderungen bei der Synchronisation
• Gemeinsamer Zustand (Shared state)
• Race Conditions
• Verwendung von sync.WaitGroup
• Mutexes und Read-/Write-Mutexes
• Atomare Operationen
• Praxis: Umwandlung einer sequenziellen Aufgabe in eine parallele Verarbeitung

18. Kanäle (Channels)

• Verständnis von Kanälen
• Senden und Empfangen von Werten
• Pufferisierte versus unpufferisierte Kanäle
• Blockierendes Verhalten
• Schließen von Kanälen
• Iterieren über Kanäle
• Richtungsgebundene Kanäle
• Kanalbasierte Kommunikation
• Select-Anweisungen
• Timeouts und Abbruch
• Worker-Pool-Muster
• Produzent/Konsument-Muster
• Praxis: Aufbau eines parallelen Worker-Systems

19. Kontext und Anfrageverwaltung

• Warum Kontexte in Webanwendungen wichtig sind
• context.Context
• Anfragebasierte Kontexte
• Abbruch (Cancellation)
• Deadline
• Timeouts
• Propagation von Kontexten durch Anwendungsschichten
• Abbruch von Datenbank- oder HTTP-Operationen
• Vermeidung eines fehlerhaften Kontextgebrauchs
• Übung: Hinzufügen von Anfrageabbruch und Timeouts zur Webanwendung

20. Testen von Go-Anwendungen

• Warum automatisiertes Testing wichtig ist
• Schreiben von Unit-Tests
• Das testing-Paket
• Testfunktionen
• Namenskonventionen für Tests
• Tabellenangetriebene Tests (Table-driven tests)
• Testen von Fehlern
• Testen von HTTP-Handler
• HTTP-Testserver
• Test-Fixtures
• Testabdeckung
• Benchmarks
• Beispiel-Tests
• Testen von Interfaces mit Mocks oder Fakes
• Praxis: Erstellung einer Testsuite für die Beispielanwendung

21. Leistungsoptimierung

• Verständnis der Leistung von Go-Anwendungen
• Identifizierung von Engpässen
• CPU- versus Speicherleistung
• Effiziente Datenstrukturen
• Reduzierung unnötiger Zuweisungen (Allocations)
• Zeichenketten, Bytes und Puffer
• Verwaltung von Goroutines
• Vermeidung übermäßiger Konkurrenz
• Caching-Strategien
• Betrachtungen zu Datenbank und Netzwerk
• Profilierung von Anwendungen
• Benchmarks und Leistungstests
• Verwendung der Profilierungstools von Go
• Übung: Profilierung und Optimierung einer absichtlich ineffizienten Anwendung

22. Sicherheit und robuste Webanwendungspraktiken

• Validierung der Benutzereingabe
• Sichere Handhabung von HTTP-Anfragen
• Vermeidung häufiger Web-Schwachstellen
• Sichere Fehlerbehandlung
• Konzepte der Authentifizierung und Autorisierung
• Verwaltung von Geheimnissen und Konfiguration
• Sichere HTTP-Kommunikation
• Vermeidung sensibler Informationen in Logs
• Verwaltung und Aktualisierung von Abhängigkeiten
• Ressourcenlimits und Anfrage-Timeouts
• Übung: Überprüfung und Härtung der Beispiel-API

23. Protokollierung und Beoabarkeit der Anwendung

• Grundlagen des Protokollierens
• Strukturiertes Protokollieren
• Log-Level
• Protokollierung von Anfragen
• Protokollierung von Fehlern
• Korrelation und Anfrage-IDs
• Überwachung des Anwendungsverhaltens
• Grundlegende Metriken
• Health-Check-Endpunkte
• Diagnose von Produktionsproblemen
• Praxis: Hinzufügen von strukturiertem Logging und Health-Checks

24. Containerisierung der Go-Anwendung

• Warum Container verwendet werden?
• Go-Anwendungen und Containerisierung
• Schreiben einer Dockerfile
• Mehrstufige Builds (Multi-stage builds)
• Aufbau eines minimalen Runtime-Images
• Verwaltung der Konfiguration über Umgebungsvariablen
• Container-Vernetzung
• Öffnen der Anwendungsports
• Ausführen der Anwendung in einem Container
• Testen der containerisierten Anwendung
• Praxis: Verpackung der Beispiel-Go-Anwendung als produktionsreifer Container

25. Bereitstellung (Deployment)

• Vorbereitung einer Anwendung für den Produktivbetrieb
• Aufbau von Produktions-Binärdateien
• Umgebungskonfiguration
• Containerbasierte Bereitstellung
• Bereitstellungsarchitektur
• Reverse Proxies
• Betrachtungen zu HTTPS/TLS
• Health-Checks der Anwendung
• Graziles Herunterfahren (Graceful shutdown)
• Verarbeitung von Betriebssystem-Signalen
• Skalierung von Go-Webanwendungen
• Horizontales versus vertikales Skalieren
• Grundlegendes Troubleshooting bei der Bereitstellung
• Praxis: Bereitstellung der Beispiel-Webanwendung

26. Abschlussprojekt: Komplette Go-Webanwendung

Die Teilnehmer wenden die Konzepte an, indem sie eine vollständige Anwendung entwickeln.

Das Projekt kann Folgendes umfassen:

• Projektinitialisierung mit Go Modules
• Paketorganisation
• HTTP-Routing
• REST-API-Endpunkte
• Verarbeitung von JSON-Anfragen und -Antworten
• Validierung der Eingabe
• Fehlerbehandlung
• Interfaces
• Parallele Verarbeitung
• Kommunikation mit externen APIs
• Persistierung von Dateien oder Datenbanken
• Automatisierte Tests
• Protokollierung
• Betrachtungen zur Leistung
• Containerisierung
• Konfiguration für den Produktivbetrieb
• Bereitstellung

27. Wiederholung und Best Practices

• Wiederholung der grundlegenden Go-Syntax
• Go-Programmierkonventionen
• Schreiben von idiomatischem Go
• Beibehaltung einfacheren Codes
• Effektives Paketdesign
• Best Practices für die Fehlerbehandlung
• Gestaltungsprinzipien für Interfaces
• Best Practices für Konkurrenz
• Teststrategien
• Betrachtungen zur Leistung
• Wartbarkeit und Lesbarkeit
• Häufige Fehler neuer Go-Entwickler
• Empfohlene Ansätze für die weitere Go-Entwicklung

28. Fazit

• Wiederholung der Schlüsselkonzepte
• Wiederholung der fertigen 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 zum Aufbau produktionsreifer Go-Dienste