Cours 21 : Résumés des livres essentiels Go

300+ lignes d'analyses détaillées de 5 livres Go fondamentaux.

---

1. The Go Programming Language (Donovan & Kernighan)

Informations

Résumé

Écrit par Brian Kernighan (co-créateur du C) et Alan Donovan (membre de l'équipe Go chez Google), ce livre est LA référence officieuse du langage Go. Il couvre l'intégralité du langage avec une approche systématique et des exemples concrets.

Structure du livre

Chapitre 1 : Tutoriel (55 pages)

• Hello, World
• Command-line arguments
• Finding duplicate lines
• GIF animation
• Fetching URLs
• Fetching concurrently
• A web server

Chapitre 2 : Programme Structure (30 pages)

• Names, Declarations
• Variables, Types, Assignments
• Scope, Pointers
• new function, Lifetime

Chapitre 3 : Basic Data Types (40 pages)

• Integers, Floating-Point, Complex
• Booleans, Strings
• Constants
• Runes and UTF-8

Chapitre 4 : Composite Types (45 pages)

• Arrays, Slices, Maps
• Structs, JSON
• Text and HTML Templates

Chapitre 5 : Functions (40 pages)

• Function declarations, Recursion
• Multiple return values, Errors
• Function values, Anonymous functions
• Variadic functions, Deferred functions
• Panic and Recover

Chapitre 6 : Methods (20 pages)

• Method declarations
• Pointer vs value receivers
• Struct embedding
• Method values and expressions

Chapitre 7 : Interfaces (35 pages)

• Interface types, Satisfaction
• Parsing flags with flag.Value
• Sorting with sort.Interface
• The error interface
• Type assertions, Type switches

Chapitre 8 : Goroutines and Channels (45 pages)

• Goroutines, Channels
• Unbuffered/Buffered channels
• Looping in parallel
• Select, Cancellation
• Example: Chat server, Concurrent web crawler

Chapitre 9 : Concurrency with Shared Variables (25 pages)

• Race conditions, Mutex
• Read/Write Mutex
• Sync.Once, Atomic operations

Chapitre 10 : Packages and the Go Tool (15 pages)

• Package declarations, Import paths
• The go tool, go build, go test

Chapitre 11 : Testing (20 pages)

• Test functions, Coverage
• Benchmark functions
• Example functions

Chapitre 12 : Reflection (15 pages)

• reflect.Type, reflect.Value
• Display, Encoding

Chapitre 13 : Low-Level Programming (10 pages)

• unsafe.Pointer, cgo

Concepts clés appris

1. Idiomes Go : tout le chapitre 7 sur les interfaces
2. Concurrence : pattern "Don't communicate by sharing memory; share memory by communicating"
3. Gestion d'erreurs : philosophie des erreurs comme valeurs
4. Testing : table-driven tests intégré
5. Interfaces : duck typing structurel

Points forts

• Écrit par des autorités du langage
• Exemples bien choisis et progressifs
• Couvre toute la stdlib utile
• Approche systématique et rigoureuse

Points faibles

• Antérieur aux generics (Go 1.18) et aux modules (Go 1.16)
• Pas de couverture des frameworks modernes (chi, gRPC, Cobra)
• Peu de contenu sur les patterns avancés

Pour qui ?

• Débutants souhaitant une base solide
• Développeurs venant du C/C++ (même style d'écriture)
• Toute personne voulant comprendre le "pourquoi" des choix Go

Temps de lecture estimé

• Lecture complète : 30-40 heures
• Chapitres clés (1, 4, 5, 7, 8, 9) : 15-20 heures
• Exercices : 10-20 heures supplémentaires

---

2. Concurrency in Go (Katherine Cox-Buday)

Informations

Résumé

Ce livre est LA référence sur la concurrence en Go. Il va bien au-delà de la syntaxe des goroutines et channels pour explorer les patterns avancés, les pièges, et les fondements théoriques de la concurrence.

Structure du livre

Partie I : Foundations

Chapitre 1 : An Introduction to Concurrency

• Différence parallélisme vs concurrence
• Loi d'Amdahl
• Pourquoi la concurrence est difficile
• Complexité du partage de mémoire

Chapitre 2 : Modeling Your Code - Communicating Sequential Processes (CSP)

• Origines du CSP (Hoare)
• Comment Go implémente CSP
• Goroutines, channels, select

Chapitre 3 : Go's Concurrency Building Blocks

• Goroutines (léger, M:N scheduler)
• sync package (WaitGroup, Mutex, RWMutex, Cond, Once, Pool)
• Channels (buffered, unbuffered, ownership)

Partie II : Patterns

Chapitre 4 : Concurrency Patterns in Go

• Confinement (ad hoc, lexical)
• For-select loop
• Or-channel
• Pipeline
• Fan-out, Fan-in
• Or-done-channel
• Tee-channel
• Bridge-channel
• Queuing
• context package

Chapitre 5 : Concurrency Patterns at Scale

• Error propagation
• Timeout and cancellation
• Heartbeats
• Replicated requests
• Rate limiting
• Healing unhealthy goroutines

Partie III : Beyond

Chapitre 6 : Goroutines and the Go Runtime

• Work stealing
• Hand-off
• Preemption
• GOMAXPROCS

Chapitre 7 : The Standard Library's Concurrency Primitives

• sync.Map
• sync.Pool
• atomic

Patterns essentiels

Or-Channel Pattern :

func or(channels ...<-chan interface{}) <-chan interface{} {
    switch len(channels) {
    case 0:
        return nil
    case 1:
        return channels[0]
    }
    orDone := make(chan interface{})
    go func() {
        defer close(orDone)
        select {
        case <-channels[0]:
        case <-channels[1]:
        case <-or(append(channels[2:], orDone)...):
        }
    }()
    return orDone
}

Tee-Channel Pattern :

func tee(done <-chan interface{}, in <-chan interface{}) (_, _ <-chan interface{}) {
    out1 := make(chan interface{})
    out2 := make(chan interface{})
    go func() {
        defer close(out1)
        defer close(out2)
        for val := range orDone(done, in) {
            var out1, out2 = out1, out2
            for i := 0; i < 2; i++ {
                select {
                case <-done:
                case out1 <- val:
                    out1 = nil
                case out2 <- val:
                    out2 = nil
                }
            }
        }
    }()
    return out1, out2
}

Points forts

• Seul livre dédié exclusivement à la concurrence Go
• Patterns avancés non documentés ailleurs
• Approche fondée sur la théorie CSP
• Nombreux exemples concrets

Points faibles

• Ne couvre pas les nouveautés (sync.Map, les generics pour la concurrence)
• Peut être trop théorique pour certains
• Exemples parfois complexes à suivre

Pour qui ?

• Développeurs Go intermédiaires/avancés
• Architectes systèmes concurrents
• Toute personne travaillant sur des systèmes distribués

---

3. 100 Go Mistakes (Teiva Harsanyi)

Informations

Résumé

Ce livre recense 100 erreurs courantes en Go, classées par catégorie, avec explications, démonstrations et solutions. Chaque erreur est présentée avec un exemple de code problématique, l'explication du problème, et la correction idiomatique.

Structure

Part 1: Code and Project Organization (Mistakes #1-#16)

• Slippery shadows, nested code, init functions
• Enums, type aliases, getters, interface pollution

Part 2: Data Types (Mistakes #17-#30)

• Integer overflow, floating-point precision
• Slice internals, nil vs empty slices
• Map iteration, zero-value structs

Part 3: Control Structures (Mistakes #31-#34)

• Range loop variable capture
• Break behavior in switch/select
• Using range on maps

Part 4: Strings (Mistakes #35-#39)

• String concatenation performance
• Substring vs rune operations
• Trim functions

Part 5: Functions and Methods (Mistakes #40-#45)

• Receiver type confusion
• Named result parameters
• Defer evaluation

Part 6: Error Management (Mistakes #46-#55)

• Error wrapping (Go 1.13+)
• Sentinel errors
• Panic in library code

Part 7: Concurrency (Mistakes #56-#75)

• Goroutine leaks
• WaitGroup misuse
• Channel closing, nil channels
• Data races, deadlocks
• Context misuse

Part 8: Testing (Mistakes #76-#85)

• Table-driven test organization
• Benchmark pitfalls
• Test helpers and cleanup

Part 9: Standard Library (Mistakes #86-#94)

• HTTP timeouts, response body
• JSON encoding pitfalls
• Time parsing, SQL NULL handling

Part 10: Tooling and Optimizations (Mistakes #95-#100)

• Escape analysis
• GC tuning
• Profiling

Erreurs marquantes

Mistake #1: Slippery Shadows

// Problème : variable shadowing dans l'initialisation if
var err error
if v, err := compute(); err != nil {
    // err ici est une NOUVELLE variable locale
}
// err ici n'a PAS été modifiée

Mistake #56: Goroutine Leaks

// Problème : goroutine bloquée indéfiniment
ch := make(chan int)
go func() {
    val := <-ch // ne retournera jamais
    fmt.Println(val)
}()
// La goroutine fuit car personne n'écrit sur ch

Mistake #72: Copying sync.Mutex

// Problème : copie d'un mutex (interdite)
type Counter struct {
    sync.Mutex
    value int
}
func (c Counter) Increment() { // receiver VALUE → copie le Mutex
    c.Lock() // ⚠️ copie de Mutex
    c.value++
    c.Unlock()
}

Points forts

• Catalogue systématique des erreurs
• Explication du "pourquoi" pour chaque erreur
• Solutions idiomatiques et testées
• Excellente référence pour les revues de code

Points faibles

• Peut être anxiogène (100 erreurs !)
• Certaines erreurs sont redondantes
• Pas de chapitre sur gRPC/generics

Pour qui ?

• Développeurs Go de niveau intermédiaire
• Toute personne faisant des revues de code
• Équipes souhaitant standardiser leurs pratiques

---

4. Go in Action (William Kennedy)

Informations

Résumé

Go in Action est un guide pratique pour les développeurs souhaitant apprendre Go par la pratique. Il se concentre sur les aspects concrets du développement Go : syntaxe, concurrence, testing, et déploiement.

Structure

Chapitre 1 : Introducing Go

• Histoire de Go
• Pourquoi Go ?
• Installation et configuration

Chapitre 2 : Go Quick Start

• Structure d'un programme
• Types, variables, constantes
• Fonctions, packages

Chapitre 3 : Packaging and tooling

• Les modules Go
• go build, go test, go get
• Gestion des dépendances

Chapitre 4 : Arrays, Slices, Maps

• Compréhension profonde des slices
• Mécanique des maps

Chapitre 5 : Go's Type System

• Structs and methods
• Interfaces
• Type embedding

Chapitre 6 : Concurrency

• Goroutines
• Channels (unbuffered/buffered)
• Patterns de concurrence

Chapitre 7 : Concurrency Patterns

• Le pattern runner
• Le pattern pool de workers
• Le pattern search

Chapitre 8 : Standard Library

• Logging, JSON
• I/O, Files
• HTTP client/server

Chapitre 9 : Testing and benchmarking

• Tests unitaires
• Tests d'intégration
• Benchmarks

Points forts

• Pratique et orienté projet
• Excellente introduction à la concurrence
• Chapitres sur les patterns concrets (runner, worker pool)
• Accessible aux débutants

Points faibles

• Daté (2015, avant les modules, generics)
• Certains exemples ne compilent plus avec Go 1.23+
• Pas de couverture des outils modernes

Pour qui ?

• Débutants complets en Go
• Développeurs souhaitant un apprentissage rapide

---

5. Let's Go (Alex Edwards)

Informations

Résumé

Let's Go est un guide pas à pas pour construire une application web professionnelle en Go. Il couvre tout le cycle : du serveur HTTP basique au déploiement en production.

Structure

Part 1 : Foundations

• HTTP servers
• Routing (servemux)
• Middleware
• Templates (html/template)
• Static files

Part 2 : Database

• SQL with database/sql
• MySQL integration
• Migrations
• Prepared statements

Part 3 : Advanced Topics

• Sessions
• CSRF protection
• Authentication (BCrypt)
• HTTPS/TLS
• File uploads

Part 4 : Production

• Testing
• Graceful shutdown
• Logging
• Rate limiting
• Deployment

Points forts

• Guide complet et cohérent (un seul projet du début à la fin)
• Très à jour (2023, Go 1.20+)
• Couvre la sécurité web (CSRF, XSS, HTTPS)
• Tests intégrés dans chaque chapitre
• Gratuit en lecture en ligne (partiellement)

Points faibles

• Ne couvre que le développement web
• Pas de concurrence avancée
• Pas de gRPC, graphQL, ou microservices

Pour qui ?

• Développeurs web débutant en Go
• Toute personne voulant construire une app web en Go de A à Z
• Auto-didactes préférant l'apprentissage par projet

---

Tableau comparatif

Recommandation finale

1. Si vous lisez UN seul livre : The Go Programming Language
2. Si vous faites du web : Let's Go (d'abord) + TGPL (ensuite)
3. Si vous faites du concurrent/systèmes distribués : Concurrency in Go
4. Si vous préparez un passage en production : 100 Go Mistakes
5. Si vous débutez et voulez un projet concret : Let's Go