Lernen Sie Go Programmierung 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 Concurrent Programming (Gleichzeitigkeit)
  • Abfallvermeidung (Garbage Collection)
  • Plattformübergreifende Kompilierung
• Typische Anwendungsfälle für Go
• Vorteile und Einschränkungen von Go
• Go im Vergleich mit C/C++, JavaScript, Ruby, Python und Java
• Das Go-Ökosystem verstehen
• Überblick über die Go-Standardbibliothek
• Go-Module und Abhängigkeitsverwaltung
• Aufbau einer Go-Anwendung
• Praktikum: Einen einfachen Go-Programm prüfen und ausführen

2. Einrichtung der Go-Entwicklungsumgebung

• Installation von Go
• Das Go-Toolchain-System verstehen
• Konfiguration von Umgebungsvariablen
• Auswahl einer IDE oder eines Code-Editors
• Arbeiten mit der Befehlszeile unter Go
• Anlegen eines Go-Arbeitsbereichs
• Die Go-Projektstruktur verstehen
• Projekt initialisieren mit Go Modules
• Nutzung von go mod init
• Verwaltung von Abhängigkeiten mit go get
• Aktualisieren und Prüfen von Abhängigkeiten
• Formatierung des Quellcodes mit gofmt
• Programme ausführen mit go run
• Anwendungen kompilieren mit go build
• Installation von Go-Anwendungen
• Kreuzkompilierung von Anwendungen
• Praktikum: Ein Go-Projekt in einer Container-Umgebung erstellen und konfigurieren

3. Go-Variablen, Konstanten und Typen

• Deklaration von Variablen
• Explizite versus abgeleitete Typen
• Kurzdeklaration von Variablen
• Konstanten
• Nulloberflächen / Nullwerte
• Geltungsbereich und Lebensdauer von Variablen
• Primitive Datentypen:
  • Ganzzahlen
  • Gleitkommazahlen
  • Komplexe Zahlen
  • Boolesche Werte
  • Zeichenketten (Strings)
• Typumwandlungen
• Arbeiten mit Unicode und UTF-8
• Runes und Bytes
• Mehrfache Zuweisung von Variablen
• Typsicherheit verstehen
• Übung: Ein kleines Befehlszeilenprogramm zur Datenverarbeitung erstellen

4. Operatoren und Ausdrücke

• Arithmetische Operatoren
• Vergleichsoperatoren
• Logische Operatoren
• Zuweisungsoperatoren
• Inkrement und Dekrement
• Operatorenpräzedenz
• Arithmetik mit Ganzzahlen und Gleitkommazahlen
• Vermeidung häufiger Fehler bei Typumwandlungen
• Übung: Berechnungen und Validierungslogik implementieren

5. Datum, Zeit und Formatierung

• Nutzung des time-Pakets 
• Erstellen und Manipulieren von Daten
• Abrufen der aktuellen Zeit
• Zeitzonen und Standorte
• Eingabe von Datums- und Zeitangaben
• Formatierung von Datum und Zeit
• Dauerberechnungen
• Arbeiten mit Unix-Zeitstempeln
• Verarbeitung von Timeouts
• Übung: Zeitstempel und Dauerberechnungen in eine Anwendung integrieren

6. Arrays, Slices, Maps und Structs

Arrays

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

Slices

• Unterschied zwischen Slices und Arrays verstehen
• Erstellen von Slices
• Hinzufügen von Elementen
• Kopieren von Slices
• Länge und Kapazität von Slices
• Teilweise Ansichten von Slices (Slicing)
• Häufige Stolpersteine 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

• Strukturen definieren

• Felder von Strukturen

• Strukturen initialisieren

• Verschachtelte Strukturen

• Anonyme Strukturen

• Methoden von Strukturen

• JSON-Struktur-Tags

• Praktikum: Nutzer, Produkte und Anwendungsdaten modellieren unter Verwendung von Structs, Slices und Maps

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
• Switch-Anweisungen basierend auf Ausdrücken
• Mehrere Fälle
• Standardfälle (Default)
• Typ-Switches (Type Switches)
• Übung: Validierungs- und Verarbeitungslogik einer Anwendung implementieren

8. Funktionen

• Definition von Funktionen
• Funktionsparameter
• Rückgabewerte
• Mehrere Rückgabewerte
• Benannte Rückgabewerte
• Variable Argumentlisten (Variadic Functions)
• Anonyme Funktionen
• Funktionswerte
• Closures (Schließungen)
• Rekursion
• Übergabe von Funktionen als Argumente
• Funktionen mit Fehler-Rückgabe
• Gestaltung kleiner, wiederverwendbarer Funktionen
• Übung: Existierenden Code in wiederverwendbare Funktionen refaktorieren

9. Zeiger und Konzepte zum Speichermanagement

• Was ist ein Zeiger?
• Adressierungs- und Dereferenzierungsoperatoren
• Zeiger und Funktionsparameter
• Zeiger-Rceiver (Pointer Receivers)
• Zeiger auf Strukturen
• Nil-Pointer
• Wann sollte man Zeiger verwenden?
• Wert- vs. Referenzsemantik
• Speicherverwaltung und Garbage Collection in Go verstehen
• Häufige Fehler bei Zeigern
• Praktikum: Anwendungsdaten mithilfe von 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
• Anfrage-URLs und Query-Parameter
• HTTP-Header
• HTTP-Statuscodes
• Grundlagen des Routings
• Erstellen von Handleern (Handlers)
• Verarbeitung von Formulardaten
• Bereitstellung statischer Dateien
• Arbeiten mit HTML-Templates
• Template-Variablen und Steuerungsstrukturen
• Strukturierung einer Webanwendung
• Praktikum: Einen grundlegenden Go-Webserver bauen

11. Erstellung eines RESTful Web Service

• Grundlagen der REST-Architektur
• Gestaltung von API-Endpunkten
• GET, POST, PUT, PATCH und DELETE
• Arbeiten mit JSON
• Kodierung und Dekodierung von JSON
• Validierung von Anfragen
• HTTP-Statuscodes
• Fehlerantworten
• Query-Parameter und Pfadparameter
• Antwortstrukturen der API
• Trennung von Handleern und Geschäftslogik
• Praktikum: Eine CRUD-REST-API erstellen

12. Go-Runtime, Kompilierung und Projektaufbau

• Den Go-Compiler verstehen
• Der Build-Prozess in Go
• go run
• go build
• go install
• go test
• Build-Flags (Kompilieroptionen)
• Umfassungskonfiguration (Environment-Specific Configuration)
• Kompilierung für verschiedene Betriebssysteme und Architekturen
• Erstellung unabhängiger Binärdateien (Standalone Binaries)
• Verwaltung der Anwendungskonfiguration
• Übung: Die Anwendung für mehrere Plattformen kompilieren

13. Arbeiten mit Dateien und dem Web

• Öffnen und Schließen von Dateien
• Dateien lesen
• Dateien schreiben
• Verzeichnisse erstellen
• Dateimetadaten
• Pufferiertes I/O (Input/Output)
• Arbeiten mit Streams
• JSON-Dateien lesen und schreiben
• HTTP-Clients
• Ausgehende HTTP-Anfragen stellen
• HTTP-Client-Fehler behandeln
• Timeouts und Abbruch (Cancellation)
• Verarbeitung von API-Antworten
• Praktikum: Daten aus einer externen API abrufen und lokal persistieren

14. Fehlerbehandlung und Fehlersuche (Debugging)

• Der Go-Ansatz zur Fehlerbehandlung
• Fehler aus Funktionen zurückgeben
• Fehler prüfen
• Benutzerdefinierte Fehler erstellen
• Fehler kapseln (Wrapping Errors)
• Kontextinformationen zu Fehlern hinzufügen
• errors.Is und errors.As
• Panic und Recovery (Panik und Wiederherstellung)
• Wann panic verwendet werden sollte
• Fehlersuche bei häufigen Go-Problemen
• Protokollierung der Aktivität der Anwendung (Logging)
• Nutzung von Go-Debugging-Tools
• Übung: Bewusst eingeführte Anwendungsfehler diagnostizieren und beheben

15. Schnittstellen (Interfaces) und Abstraktion

• Was ist eine Schnittstelle (Interface)?
• Implizite Schnittstellenimplementierung
• Definition von Schnittstellen
• Schnittstellenwerte
• Leere Schnittstellen und any /
• Typ-Assertions
• Typ-Switches
• Implementierung über Zeiger vs. Werte
• Gestaltung kleiner Schnittstellen
• Invertierung von Abhängigkeiten
• Nutzung von Schnittstellen für Tests
• Reduzierung der Kopplung in Anwendungen
• Praktikum: Schnittstellen in die Beispielmuster-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 Modules
• Semantisches Versioning
• Nutzung von Paketen Dritter
• Vermeidung zirkulärer Abhängigkeiten
• Gestaltung wartbarer Go-Projekte
• Übung: Die Anwendung in separate Pakete refaktorieren

17. Concurrent Programming mit Goroutines

• Was ist Concurrent Programming?/li>
• Goroutines
• Starten von Goroutines
• Leichtgewichtige Concurrent-Ausführung verstehen
• Herausforderungen der Synchronisation
• Gemeinsam genutzter Zustand (Shared State)
• Wettlaufbedingungen (Race Conditions)
• Nutzung von sync.WaitGroup
• Mutexe und Read/Write-Mutexe
• Atomare Operationen
• Praktikum: Eine sequenzielle Aufgabe in Concurrent-Verarbeitung umwandeln

18. Kanäle (Channels)

• Kanäle verstehen
• Senden und Empfangen von Werten
• Pufferlose vs. gepufferte Kanäle
• Blockierendes Verhalten
• Schließen von Kanälen
• Iterieren über Kanäle
• Richtungsabhängige Kanäle
• Kanäle als Kommunikationsmechanismus
• Select-Anweisungen
• Timeouts und Abbruch
• Worker-Pool-Muster
• Producer/Consumer-Muster
• Praktikum: Ein Concurrent-Worker-System bauen

19. Kontexte und Request-Verwaltung

• Warum Kontexte in Webanwendungen wichtig sind
• context.Context
• Request-spezifische Kontexte
• Abbruch (Cancellation)
• Deadlines (Fristen)
• Timeouts
• Kontexte durch Anwendungsschichten propagieren
• Abbruch von Datenbank- oder HTTP-Operationen
• Fehlerhafte Nutzung von Kontexten vermeiden
• Übung: Request-Abbruch 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
• Tabellenbasierte Tests
• Testen von Fehlern
• Testen von HTTP-Handleern
• HTTP-Testserver
• Test-Fixtures
• Testabdeckung
• Benchmarks
• Beispiel-Tests
• Testen von Schnittstellen mit Mocks oder Fakes
• Praktikum: Eine Testsuite für die Beispielmuster-App erstellen

21. Performance-Optimierung

• Performance von Go-Anwendungen verstehen
• Engpässe identifizieren
• CPU- vs. Speicherperformance
• Effiziente Datenstrukturen
• Vermeidung unnötiger Allokationen
• Strings, Bytes und Puffer
• Goroutine-Management
• Exzessive Concurrent-Aktivität vermeiden
• Caching-Strategien
• Betrachtung von Datenbank- und Netzwerkaspekten
• Profiling von Anwendungen
• Benchmarks und Performance-Tests
• Nutzung der Profiling-Tools von Go
• Übung: Eine bewusst ineffiziente Anwendung profilieren und optimieren

22. Sicherheit und robuste Webanwendungspraktiken

• Validierung von Nutzereingaben
• Sichere Behandlung von HTTP-Anfragen
• Vermeidung gängiger Web-Sicherheitslücken
• Sichere Fehlerbehandlung
• Konzepte der Authentifizierung und Autorisierung
• Verwaltung von Secrets und Konfiguration
• Sichere HTTP-Kommunikation
• Vermeidung sensibler Informationen in Logs
• Verwaltung und Aktualisierung von Abhängigkeiten
• Ressourcenlimits und Request-Timeouts
• Übung: Die Beispiel-API überprüfen und absichern

23. Application Logging und Observability

• Grundlagen des Loggings
• Strukturiertes Logging
• Log-Level/s
• Request-Logging
• Error-Logging
• Korrelation und Request-IDs
• Monitoring des Verhaltens der Anwendung
• Grundlegende Metriken
• Health-Check-Endpoints
• Diagnose von Produktionsproblemen
• Praktikum: Strukturiertes Logging und Health-Checks hinzufügen

24. Containerisierung der Go-Anwendung

• Warum Container nutzen?/li>
• Go-Anwendungen und Containerisierung
• Schreiben einer Dockerfile
• Mehrstufige Builds (Multi-stage Builds)
• Aufbau eines minimalen Runtime-Images
• Konfiguration über Umgebungsvariablen
• Container-Netzwerk
• Öffnen der Anwendungsports
• Ausführung der Anwendung in einem Container
• Testen der containerisierten Anwendung
• Praktikum: Die Beispiel-Go-Anwendung als produktionsreifer Container verpacken

25. Deployment (Betriebseinführung)

• Vorbereitung einer Anwendung für den Produktivbetrieb
• Aufbau von Produktions-Binaries
• Umgebungskonfiguration
• Container-basiertes Deployment
• Deployment-Architektur
• Reverse Proxies
• HTTPS/TLS-Betrachtungen
• Anwendungs-Health-Checks
• Geordneter Shutdown (Graceful Shutdown)
• Bearbeitung von Betriebssystem-Signalen
• Skalierung von Go-Webanwendungen
• Horizontales vs. vertikales Skalieren
• Grundlegende Fehlersuche beim Deployment
• Praktikum: Die Beispiel-Webanwendung deployen

26. Capstone: Komplett Go-Webanwendung

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

Das Projekt kann umfassen:

• Projektinitialisierung mit Go Modules
• Paketorganisation
• HTTP-Routing
• REST-API-Endpoints
• JSON-Request- und -Antwortverarbeitung
• Eingabevalidierung
• Fehlerbehandlung
• Schnittstellen (Interfaces)
• Concurrent-Verarbeitung
• Kommunikation mit externen APIs
• Datei- oder Datenbankpersistenz
• Automatisierte Tests
• Logging
• Betrachtungen zur Performance
• Containerisierung
• Produktionskonfiguration
• Deployment

27. Review und Best Practices

• Review der Kern-Go-Syntax
• Go-Coding-Konventionen
• Idiomatisches Go schreiben
• Code einfach halten
• Effektives Paketdesign
• Best Practices zur Fehlerbehandlung
• Prinzipien des Schnittstellendesigns
• Best Practices für Concurrent-Programmierung
• Teststrategien
• Betrachtungen zur Performance
• Wartbarkeit und Lesbarkeit
• Häufige Fehler neuer Go-Entwickler
• Empfohlene Ansätze für die weitere Go-Entwicklung

28. Schlusswort

• Review der wichtigsten Konzepte
• Review der abgeschlossenen Webanwendung
• Fragen und Diskussion
• Fehlersuche in üblichen Real-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