🇫🇷 Version française disponible ici

Go avancé (Advanced Go)

Inside the runtime: architecture, concurrency and optimizations

Go avancé describes the internals of the Go language : how the runtime works, how memory is managed, how the built-in data structures are laid out, and how concurrency is implemented. It is based on the official sources and on the golang/go repository, and it covers Go 1.26 and later.

Details and ordering on the Éditions D-BookeR website

Print edition and the Fnac and Amazon listings will be available on the release date, 22 September 2026.

Who this book is for

The reader can already write Go. They know goroutines and channels, they may use the language in production, and they are asking deeper questions : how the scheduler picks the next goroutine to run, why some variables escape to the heap, how maps handle collisions.

The goal is not to turn the reader into a compiler developer, but to provide what is needed to make informed architecture decisions under memory, latency and load constraints.

Prerequisites : regular practice of Go. Some systems and assembly background helps but is not required.

What this book is not

• an introductory Go tutorial ;
• an exhaustive language reference ;
• a catalogue of ready-made solutions ;
• a general best-practices guide.

To our knowledge, there is no French-language book covering the Go runtime at this depth.

Topics covered

Subjects addressed in the book, rarely documented at this level :

• the G-M-P model and scheduler internals, work stealing, hand-off on blocking syscalls ;
• size-class allocator, spans, arenas, the mcache / mcentral / mheap hierarchy ;
• the concurrent tri-color garbage collector, and the Green Tea algorithm introduced in Go 1.26 ;
• escape analysis, dynamic stack growth and shrinking ;
• GCShape stenciling of generic types ;
• network poller (epoll, kqueue), sysmon, signal-based preemption ;
• the memory model and happens-before relations ;
• the unsafe package and reflection.

Table of contents

Part 1: Runtime foundations

1. Architecture and concurrency model
2. Runtime bootstrap and initialization
3. The Go memory model
4. Memory allocation and management
5. Garbage collector and memory reclamation
6. Memory observability and optimization
7. Architecture and scheduling
8. Runtime components and monitoring

Part 2: Types and data structures

9. Data structure foundations
10. Slices and arrays, internal representation
11. Strings, internal representation and immutability
12. Maps, internal hash tables
13. Interfaces and the type system
14. Generics, compile-time polymorphism

Part 3: Advanced language mechanisms

15. Switch and case selection
16. Anonymous functions and closures
17. Defer, execution guarantees
18. Panic and recover
19. Range-over-function iterators
20. The unsafe package
21. Reflection, introspection and dynamic manipulation
22. Compilation and optimizations

Part 4: Mastering concurrency

23. Goroutines, internal mechanisms
24. Synchronization primitives
25. Advanced synchronization functions
26. Channels, communication and signaling
27. Tools for concurrent programming

Appendices

• 20 technical demonstrations and reproducible benchmarks ;
• 4 algorithmic appendices : binary heaps, quadratic probing, division-by-constant optimization ;
• glossary and index.

Method

Explanations rely on the official sources (go.dev, the golang/go source tree). Demonstrations and benchmarks are measured on two architectures : Intel Core i7 and Apple M4 Pro.

Publisher

Éditions D-BookeR, 229 rue Solférino, 59000 Lille, France.
Edition 1, version 1.0, 2026. PDF ISBN : 978-2-8227-1187-6.

Publisher page and ordering