Learn the why.
Master the how.

The library we train our own engineers with — from senior to principal. Published as we finish it, written to the same production standard as everything else we ship.

Go from Zero to Production ○ BOOK Go Concurrency ◐ COURSE Distributed Computing Foundations ◐ Distributed Infrastructure in Go ○ Production Distributed Systems ○

labs › catalog

The Library

The full syllabus of every title is published before launch — the same way our case studies publish the ADRs. What you see below is the actual table of contents, with honest build status.

labs/go-concurrency/book.md ● 10/22 BUILT · OPENING Q4

BOOK

Go Concurrency: From Fundamentals to Production

Correct mental models first — goroutines, channels, select — then channel mastery, shared state and the memory model, context and cancellation, and the production discipline: testing, debugging, and performance, down to the GMP scheduler.

progress › 10 built · 4 in draft · 8 queued · all 22 mapped

Start reading — chapters 1–10 → Anatomy of a chapter →

syllabus › all 22 chapters mapped · ✓ = built · read → = open now

part 1 › foundations

01understanding concurrencyread → 02goroutinesread → 03channelsread → 04selectread →

part 2 › channel mastery

05buffered channelsread → 06directional channels & api designread → 07channel patternsread →

part 3 › shared state

08data races & the memory modelread → 09mutexesread → 10deadlocksread →

11atomic operationsdraft

12the sync packagedraft

part 4 › context & cancellation

13contextdraft

14error handling in concurrent codedraft

15graceful shutdownqueued

part 5 › production practices

16testing concurrent codequeued

17rate limiting & flow controlqueued

18common bugs & code reviewqueued

part 6 › debugging & performance

19debugging concurrent programsqueued

20performance optimizationqueued

part 7 › advanced topics

21scheduler & runtime internals — gmpqueued

22case studies — crawler · jobs · pipelinequeued

appendices

a–dquick reference · from other languages · toolsqueued

labs/distributed-systems/course-1-foundations.md ◐ IN DEVELOPMENT · 4/22 BUILT

COURSE · 1 OF 3

Distributed Computing Foundations in Go

The first course of the Distributed Systems in Go series — the bridge from concurrent to distributed. Real networking, wire protocols, serialization, RPC and gRPC, time and causality, failure detection — closing with a build project: a distributed key-value store, v1.

progress › 4 built · 1 in draft · 17 queued · all 22 mapped

syllabus › all 22 chapters mapped · ✓ = built

part 1 › the distributed mindset

01from concurrent to distributed✓

02networks, failures & the eight fallacies✓

03failure models & the distribution decision✓

part 2 › networking in go

04tcp networking in go✓

05connection managementdraft

06building wire protocolsqueued

07http & http/2 in goqueued

08transport security — tls & mtlsqueued

part 3 › serialization & data exchange

09serialization fundamentalsqueued

10protocol buffers in goqueued

11schema evolution & compatibilityqueued

part 4 › remote procedure calls

12rpc concepts & semanticsqueued

13an rpc framework from scratchqueued

14grpc in goqueued

15api design for distributed servicesqueued

part 5 › time, order & causality

16physical time & its limitationsqueued

17logical clocksqueued

18hybrid logical clocksqueued

part 6 › failure detection & resilience

19failure detectionqueued

20timeouts & retriesqueued

21idempotency & safe operationsqueued

22circuit breakers & partial failurequeued

build project

kvdistributed key-value store — v1queued

Go from Zero to Production

○ BOOK · QUEUED

The on-ramp — the Go language itself, taught to the same depth as everything here. The natural first read, before the concurrency book.

Distributed Infrastructure in Go

○ COURSE 2 · MAPPED

Consistency and replication, consensus, partitioning, distributed transactions, storage, and event systems — the machinery under every reliable platform.

Production Distributed Systems in Go

○ COURSE 3 · MAPPED

Service architecture, reliability engineering, testing, observability, multi-region, and workflow orchestration — running distributed systems for real.

labs › routing

Where do I start?

The library tells one story. The books make you dangerous on a single machine; the courses take you across the network — where every guarantee you relied on stops holding.

ONE MACHINE

Go from Zero to Production

the language · types · interfaces · tooling

○ book · queued · the on-ramp

Go Concurrency

goroutines · channels · one process

◐ 9/22 built · start here

MANY MACHINES

Distributed Computing Foundations

sockets · rpc · time · failure

◐ in development · course 1

Distributed Infrastructure

replication · consensus · sharding

○ course 2 · mapped

Production Distributed Systems

reliability · multi-region · operations

○ course 3 · mapped

everything left of the line is one process — everything right of it is the hard part

# fallacy 01 › ~~"the network is reliable"~~ — the courses begin where it stops being true

labs › quality

Anatomy of a chapter

We won't tell you the material is good — here is a spread from chapter 5, one of the nine already written and built: the why, the diagram in the book's own hand, the production pattern, and the test that decides whether you're done.

ch 05 › buffered channels — as counting semaphores

Unbounded is a bug you haven't hit yet

Spawning a goroutine per task feels free — until 40,000 of them open sockets at once and your crawler DoSes the very API it depends on. Concurrency isn't the goal; bounded concurrency is. The bound is a design decision, and it belongs in the code, not in a comment.

KEY INSIGHT

A buffered channel is a semaphore: its capacity is your maximum in-flight work. Acquire by sending, release by receiving — the scheduler enforces the bound for you.

CHANNEL AS SEMAPHORE

 acquire › sem <- struct{}{}      release › <-sem

         ┌────────────────────────┐
 work ──▶│ ●  ●  ●  ●  ●  ●  ●  ● │──▶ ≤ 8 in flight
         └────────────────────────┘
                capacity = 8
    g9 ──▶ blocked — waiting for a slot
    g10 ─▶ blocked

 · the buffer IS the bound — no counter, no mutex
 · release in defer — a panic can't leak a slot

figure 5.7 — drawn the way every diagram in the book is drawn

ch05/crawler.go — the pattern, as it ships

// The channel's capacity IS the concurrency bound.
sem := make(chan struct{}, maxInflight)

var wg sync.WaitGroup
for _, u := range urls {
    sem <- struct{}{}             // acquire — blocks at the bound
    wg.Go(func() {                // Go 1.25 — see ch 02
        defer func() { <-sem }()  // release — always, even on panic
        crawl(ctx, u)
    })
}
wg.Wait()

exercise 5.4 › bound the crawler

$ go test ./ch05 -run TestCrawler_MaxInflight -race
--- FAIL: TestCrawler_MaxInflight (0.02s)
crawler_test.go:41: max concurrent fetches = 214, want ≤ 8
— your move. done when it reads:
ok corelabs/ch05 0.31s

Every chapter ends with a failing test. You're done when it passes — not when a video ends.

labs › pipeline

How a chapter ships

Quality is an easy claim and a hard process. Every chapter clears six gates before it reaches the shelf — the same discipline our case studies document for systems, applied to teaching them.

written› compiles› survives -race› exercise fails› tech review› published

01written

Text-first, by the engineers in the case studies. Prose you can grep, skim, and quote — nothing padded for watch time.

02it compiles

Every listing is extracted from the chapter and built in CI. If a snippet fails go vet, the chapter stops here.

03it survives -race

Examples and exercise solutions run under the race detector — the same bar our production code has to clear.

04the exercise fails

Each chapter ships an exercise as a failing test. It must fail for the right reason before it's allowed to teach.

05tech review

A second senior engineer reads for honesty: true prerequisites, true hours, and not one number we can't back.

06published

The chapter reaches the shelf and the shipping log. Anything found later is fixed in public — changelog and all.

in the pipeline now › go-concurrency ch 01–09 · awaiting publish ch 10–14 · in draft ch 15–22 · queued foundations ch 05 · in draft

labs › changelog

The shipping log

Courses get roadmaps here for the same reason systems get status pages — "coming soon" is not a status.

2026-08corelabs opens — the shelf, the syllabi, the shipping logLIVE

2026-Q4go-concurrency — chapters 1–10 go liveNEXT

2027-Q1go-concurrency — chapters 10–14, in draftPLANNED

2027distributed-computing-foundations — early accessPLANNED

2027distributed-infrastructure — course 2 drafting beginsPLANNED

notify ›

One email when a title ships.

No drip campaign, no newsletter — the log on the left, delivered once per release, nothing else.

✓ subscribed — one email when a title ships

something broke — email us instead: contact@corebackend.dev

Learn the why.Master the how.

The Library

Go Concurrency: From Fundamentals to Production

Distributed Computing Foundations in Go

Go from Zero to Production

Distributed Infrastructure in Go

Production Distributed Systems in Go

Where do I start?

Go from Zero to Production

Go Concurrency

Distributed Computing Foundations

Distributed Infrastructure

Production Distributed Systems

Anatomy of a chapter

Unbounded is a bug you haven't hit yet

How a chapter ships

The shipping log

One email when a title ships.

Learn the why.
Master the how.