Go, for someone who already ships Java.

Every lesson is three panes: idiomatic Go, the Java you would have written, and the TypeScript that maps closest to Go's structural typing. Work top to bottom; each module ends with a checkpoint you can prove.

13lessons live

12modules

116hfull track

Toolchain: build, run, test

What Maven, the JVM, and application.yml do for you — and the four commands that replace all of it.

2 lessons · 70 min

go build is the whole build system 30m
No pom.xml, no dependency resolution graph to debug, no classpath. One command, one static binary.
A JSON endpoint in 40 lines, no framework 40m
net/http + encoding/json against Spring Boot and Express. This is the moment Go starts feeling like cheating.

Types: no classes, no inheritance

Structs, methods, embedding, and interfaces that are satisfied implicitly. The biggest mental shift after the toolchain.

2 lessons · 85 min

Structs, embedding, and interfaces nobody declares 45m
Composition is the only inheritance Go has, and interfaces are satisfied by accident — on purpose.
Value semantics and the nil-interface trap 40m
Everything is passed by value. Slices and maps lie about it. And a non-nil interface holding a nil pointer is the bug you will ship once.

Collections, strings, memory

Slices that alias, maps that never order, bytes vs runes, and where your allocations actually go.

3 lessons · 105 min

Slices are headers, maps are pointers 40m
One slice bug explains half of all Go production incidents. Learn it here, not in an outage.
Strings are bytes, characters are runes 30m
len() lies to you, indexing splits characters in half, and string concatenation in a loop is the oldest Go performance bug.
Where the memory goes 35m
Stack vs heap, struct padding, and why Go's GC asks you a different question than the JVM's.

Errors are values

No exceptions. Wrapping with %w, sentinel errors, errors.Is/As, and defer instead of try-with-resources.

2 lessons · 80 min

Errors are values, not control flow 45m
No try/catch, no checked exceptions, no stack unwinding. An error is just the last return value — and that changes your design.
Wrapping in practice: Join, defer, and boundaries 35m
Where to translate, where to log, and how to keep a cause chain intact through five layers of your own code.

Concurrency: the hiring differentiator

Goroutines against virtual threads (JEP 444), channels, select, context, errgroup, and the race detector.

4 lessons · 180 min

Goroutines vs virtual threads 50m
The reason Go gets hired for: 2 KB stacks, an M:N scheduler, and no pool. Java's answer is threads again — with different trade-offs.
Channels and select: the whole API 45m
Five rules, two traps, one direction arrow. Channels are not queues and not futures — they are synchronisation points.
context: cancellation is an argument 35m
Java interrupts threads and cancels futures. Go passes a context down every call, and reviewers will reject code that doesn't.
Worker pools, errgroup, and the race detector 50m
The three patterns you will actually write at work, plus the tool that makes concurrency bugs reproducible instead of mystical.

Composition over Spring

Constructor injection, functional options, small interfaces, and why struct tags replace annotations.

0 lessons