Training Module

Go-Grundlagen

In diesem ca. 8-stündigen Modul lernt ihr Go von der ersten Zeile bis zu nebenläufigem, getestetem Code: Sprachgrundlagen und Kontrollstrukturen, Slices und Maps, Funktionen und Structs, Interfaces, Paketverwaltung, Error Handling, Concurrency mit Goroutinen und Channels sowie Testing mit Table-Driven Tests, Benchmarks, Coverage und Fuzzing. Keine Go-Vorkenntnisse nötig – ein Grundverständnis von Terminal/Kommandozeile hilft.

Academy Briefing vereinbaren

Oder sofort per Mail an kontakt@codecraft.academy

Format

ca. 8 Stunden, live (remote oder vor Ort) – als Tagesworkshop oder in 2 Halbtagen, Input & Hands-on

Teilnehmende

Entwickler:innen mit Grunderfahrung in einer beliebigen Programmiersprache, die Go von Grund auf lernen wollen

Voraussetzungen

Keine Go-Vorkenntnisse nötig; Grundverständnis von Terminal/Kommandozeile hilfreich

Warum dieses Training für deine Organisation wirkt

Von der ersten Zeile zum nebenläufigen Programm

Kein Sprung ins kalte Wasser: Der Bogen läuft von package main und einfacher I/O bis zu Goroutinen, Channels und synchronisiertem Warten mit sync.WaitGroup.

Go-Denken statt Syntax pauken

Value- vs. Pointer-Receiver, exportierte vs. unexportierte Bezeichner, implizite Interface-Erfüllung: Teilnehmende verstehen, warum Go-Code so aussieht, wie er aussieht – nicht nur, wie man ihn abtippt.

Testbar von Anfang an

Table-Driven Tests, Mocking, Benchmarks, Coverage und Fuzzing sind ein eigenes Modul, kein Anhängsel – Code aus dem Kurs entsteht von Anfang an in testbarer Form.

Was Teilnehmende mitnehmen

  • Go-Programme mit package main, Variablendeklaration (var, :=) und Typinferenz schreiben, inklusive Ein-/Ausgabe über Println/Printf-Verbs und Scan.
  • If/Else ohne Klammernpflicht, Switch ohne break und die vier for-Varianten von Go sicher einsetzen.
  • Slices (append, Lösch-Pattern) und Maps (make) als dynamische Datenstrukturen nutzen.
  • Funktionen mit mehreren Rückgabewerten schreiben und Value- von Pointer-Receivern bei Methoden unterscheiden.
  • Structs kapseln (Exported/Unexported), Getter/Setter und Konstruktor-Funktionen (New…) einsetzen.
  • Interfaces und implizite Erfüllung („Enten-Typisierung”) für polymorphen Code nutzen.
  • Go-Projekte mit go.mod/go.sum strukturieren, Abhängigkeiten mit go get/go mod tidy verwalten und eigene Packages schreiben.
  • Fehler mit dem error-Interface, errors.New/fmt.Errorf, Wrapping sowie errors.Is/errors.As und Custom Errors behandeln.
  • Nebenläufigen Code mit Goroutinen, Channels und sync.WaitGroup schreiben.
  • Table-Driven Tests (mit Testify), Mocking, Benchmarks, Coverage und Fuzz-Tests einsetzen.

Für wen dieses Modul ideal ist

  • • Entwickler:innen mit Grunderfahrung in einer beliebigen Programmiersprache
  • • Einsteiger:innen in Go, die von der ersten Zeile bis zu nebenläufigem, getestetem Code kommen wollen
  • • Alle, die keine Go-Vorkenntnisse mitbringen, aber mit Terminal/Kommandozeile grundsätzlich vertraut sind

Rahmendaten

  • • Dauer: ca. 8 Stunden live (remote oder vor Ort) – Schätzung, als Tagesworkshop oder in 2 Halbtagen
  • • Format: Input, Live-Coding, Hands-on-Übung
  • • Voraussetzungen: Keine Go-Vorkenntnisse nötig, Grundverständnis von Terminal/Kommandozeile hilfreich

Modulaufbau & Agenda

  1. Sprachgrundlagen & I/O (ca. 45 min): package main, var/:=/Typinferenz, Println/Printf-Verbs, Scan mit &.

  2. Kontrollstrukturen (ca. 45 min): If/Else ohne Klammernpflicht, Switch ohne break, die vier for-Varianten.

  3. Dynamische Datenstrukturen (ca. 30 min): Slices (append, Lösch-Pattern), Maps (make).

  4. Funktionen & Methoden (ca. 45 min): mehrere Rückgabewerte, Value- vs. Pointer-Receiver.

  5. Structs, Kapselung, OOP-Muster (ca. 40 min): Exported/Unexported, Getter/Setter, Konstruktor-Funktionen New….

  6. Interfaces & Polymorphismus (ca. 30 min): implizite Erfüllung („Enten-Typisierung”).

  7. Paketverwaltung & Projektstruktur (ca. 40 min): go.mod/go.sum, go get, go mod tidy, eigene Packages.

  8. Struct-Vergleich & Error Handling (ca. 50 min): error-Interface, errors.New/fmt.Errorf, Wrapping, errors.Is/errors.As, Custom Errors.

  9. Concurrency (ca. 40 min): Goroutinen, Channels, sync.WaitGroup.

  10. Testing, Benchmarks, Coverage, Fuzzing (ca. 65 min): Table-Driven Tests, Testify, Mocking, Benchmarks, Coverage, Fuzz-Tests.

  11. Hands-on-Übung (ca. 45 min): eine SumConcurrently-Funktion mit Goroutinen, Channel und sync.WaitGroup schreiben, dazu einen Table-Driven-Test mit Error-Fall.

Gesamtdauer ca. 8 Stunden (Schätzung) – als Tagesworkshop oder in 2 Halbtagen: Teil 1 (Block 1–3) ca. 2 Stunden, Teil 2 (Block 4–10 + Übung) ca. 6 Stunden.

Hands-on Inhalte (Auszug)

Sprachgrundlagen, Kontrollfluss & Datenstrukturen

  • package main, Variablen & Typinferenz, Ein-/Ausgabe
  • If/Else, Switch ohne break, die vier for-Varianten
  • Slices und Maps im praktischen Zugriff

Funktionen, Methoden & Structs

  • Mehrere Rückgabewerte pro Funktion
  • Value- vs. Pointer-Receiver bei Methoden
  • Structs kapseln, Getter/Setter, Konstruktor-Funktionen New…

Interfaces, Pakete & Error Handling

  • Implizite Interface-Erfüllung („Enten-Typisierung”)
  • go.mod/go.sum, go get, go mod tidy, eigene Packages
  • error-Interface, Wrapping, errors.Is/errors.As, Custom Errors

Concurrency & Testing

  • Goroutinen, Channels, sync.WaitGroup
  • Table-Driven Tests mit Testify, Mocking
  • Benchmarks, Coverage, Fuzz-Tests

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zum ersten lauffähigen Programm, Ergebnis der Hands-on-Übung) und werten sie im Anschluss transparent aus. Ergebnisse veröffentlichen wir, sobald sie belastbar sind.

Bereit, das Modul zu buchen?

Wir passen die Hands-on-Übung auf euren Erfahrungsstand und eure Zielumgebung an.

Academy Briefing anfragen