Training on jub0bs.com

Generics and iterators in Go

Fri, 10 Apr 2026 00:00:00 +0000

This course serves as an introduction to generics and iterators, two closely related features of the Go programming language. Generics hold the promise efficient and reusable data structures and functions without sacrificing correctness. As for iterators, which are built on generics, they promote flexibility and performance.

Duration ¶

2 days (14 hours)

Prerequisites ¶

Fluency in English
Experience with Go and a good understanding of functions, interfaces, and methods
A basic knowledge of Git
A personal computer (preferably running macOS or Linux) on which the following tools have been installed (ahead of the course):
- Go 1.26+
- Visual Studio Code and its Go extension, or your preferred IDE or text editor
- Git
A stable Internet connection

Outline ¶

Day 1: Generics ¶

Preamble
- Generics (a.k.a. parametric polymorphism)
- Use cases for generics
- A brief history of the advent of generics in Go
Type parameters
- Syntax
- Naming conventions
- Type arguments and instantiation
- Type inference
Generic functions
- Syntax
- The slices and maps packages
Generic types
- Syntax
- Methods of generic types
- Current restrictions on methods of generic types
Generic type aliases
- Refresher about type aliases
- Syntax
Type constraints
- A kind of meta-type expressed as interfaces
- Interfaces viewed as a set of types
- The predefined any type constraint
- The predefined comparable type constraint
- Beware of comparable types composed of values for which equality is non-reflexive
- Type union
- Set of types based on a common underlying type (e.g. ~string)
- The cmp package and the cmp.Ordered type constraint
- The golang.org/x/exp/constraints package
- Restrictions on type constraints
- To constrain or not to constrain: that is the question
Advanced techniques
- Pointer-type constraints
- Recursive type constraints
- Phantom types
When not to use generics
- Alternative approaches: reflectionm, code generation
- A case study of generics abuse
Learning resources

Labs:

Concurrent programming in Go

Thu, 09 Apr 2026 00:00:00 +0000

This short course (recently refreshed for Go 1.26) aims at demystifying Go’s main concurrency features: goroutines, channels, mutexes, select statements, and contexts. Through a series of practical exercises, you’ll learn how to use concurrency to your advantage and avoid its many pitfalls.

Duration ¶

1 day (7 hours)

Prerequisites ¶

Fluency in English
Experience with the basics of Go but not necessarily with its concurrency features
A basic knowledge of Git
A personal computer (preferably running macOS or Linux) on which the following tools have been installed (ahead of the course):
- Go 1.26+
- Visual Studio Code and its Go extension, or your preferred IDE or text editor
- Git
A stable Internet connection

Outline ¶

Presentation of the namecheck project
- namecheck: a CLI tool for checking the validity and availability of usernames on social media (GitHub, Reddit, etc.)
- Motivations for developing such a tool
Introduction to concurrency
- Concurrency: the art of composing a program in order to delineate independent tasks
- Concurrency vs. parallelism: close but distinct
- Concurrency enables parallelism and promises free performance gains as the number of cores increases
- Amdahl’s law and Gunther’s law: parallelism’s diminishing returns
- Go’s concurrency trifecta: goroutines, channels, et select statements
Goroutines
- Goroutines: featherweight threads
- The Go scheduler
- Starting goroutines with the go keyword
- The golden rule: don’t start a goroutine if you can’t explain when it will terminate
- The main function doesn’t wait for other goroutines to terminate
- Wait groups
- Synchronization bugs and race conditions
- Concurrency safety
- Data races
- Race detector
Channels
- Shared-memory concurrency vs. message-passing concurrency
- Share memory by communicating
- Channels: the preferred mechanism for communicating between goroutines
- Naming conventions
- Channels are values just like any other
- The zero value of channel types
- Initializing a channel via the make builtin
- Capacity of a channel
- Channels are FIFO
- On the importance of choosing a channel’s capacity judiciously
- Sending a value to a channel
- Receiving a value from a channel
- Lifting ambiguity at receiption with the comma-ok idiom
- Deadlock
- Goroutine leak
- Closing a channel
- Good and bad reasons to close a channel
- Ranging over a channel
- Directional channels
HTTP server
- Introduction to the net/http package
- A simple “Hello, World!” server
- What about Web frameworks?
- Beware: handlers are invoked concurrently
A short detour in the land of shared-memory concurrency
- Communicating by sharing memory
- Mutexes and critical sections
- The sync.Mutex type
Select statements
- Multiplexing channel communications
- The select keyword
- Event loop: a select statement nested in a loop
Canceling goroutines
- The need to force goroutines to terminate
- Emit and detect a cancellation signal: the basic technique
- The context.Context type
- Emit and detect a cancellation signal: the modern approach
- Cancelable channel send
- context.Background() and context.TODO()
- Deriving contexts
- Cancellation signals propagate down the tree of contexts
- Embrace “cancel culture”: design most of your functions as cancelable
- Contexts on the client side and on the (Web) server side
Learning resources

Labs:

Introduction to Web security

Thu, 09 Apr 2026 00:00:00 +0000

Under construction

Introduction to Go

Wed, 08 Apr 2026 00:00:00 +0000

If you have programming experience with another language and would like to get started with Go, look no further than this course (recently refreshed for Go 1.26). Covering basic syntax, object orientation, and concurrency fundamentals, it promises to set you on a path to proficiency with the Go programming language. Far from being merely theoretical, the course is punctuated by practical exercices aiming at iteratively improving a CLI tool ultimately turned into a small Web application.