become_top_devSe connecter

Apprends à coder en pratiquant.

Trois cours tirés de livres de référence : Go, systèmes de données, architecture logicielle. Tu lis, tu codes, tu passes les tests, puis tu avances.

Se connecterVoir les 3 cours

Un module, quatre gestes

Chaque geste rapporte de l'XP. Le module suivant s'ouvre quand tu maîtrises celui-ci.

  1. Lire

    Une leçon courte, tirée du livre, avec la page d’origine.

    +30 XP

  2. Coder

    Un exercice dans l’éditeur, exécuté pour de vrai.

    indices au besoin

  3. Valider

    Des tests valident ton code. Pour l’architecture, une grille d’évaluation.

    +50 XP

  4. Ouvrir la suite

    Le module suivant s’ouvre quand tu maîtrises celui-ci.

    module suivant

Trois cours

Commence par Go : les exercices des deux autres cours s'écrivent en Go. Chaque cours a un projet fil rouge qui grandit à chaque module.

  1. 1

    Go idiomatique

    D'après Learning Go, 2nd Edition, Jon Bodner

    Le langage, de la première variable à la concurrence et aux tests, en écrivant du Go qui compile et qui passe ses tests.

    Relay — un mini-service de jobs

    Un service HTTP construit module après module : types, erreurs, concurrence, API, tests.

    len=2 cap=1515 modules en 4 parcours, 2 déjà prêts

  2. 2

    Systèmes de données

    D'après Designing Data-Intensive Applications, Martin Kleppmann

    Comment une base stocke, réplique, partitionne et garde ses données cohérentes. Chaque mécanisme du livre est reconstruit en petit, en Go.

    Conseillé après Go idiomatique, jusqu'au module « Concurrence ». Les TP manipulent goroutines, channels et verrous dès la réplication.

    Tinybase — un mini-système de données

    Un moteur clé-valeur en Go qui grandit module après module : log, index, réplication, partitions, transactions, consensus, flux.

    len=0 cap=1818 modules en 3 parcours, rédaction en cours

  3. 3

    Architecte logiciel

    D'après Fundamentals of Software Architecture, Mark Richards et Neal Ford

    Raisonner en trade-offs : caractéristiques, styles, décisions et risques. Des katas et des ADR notés par rubrique, et des outils Go qui mesurent l'architecture.

    Conseillé après Go idiomatique, jusqu'au module « Types, méthodes et interfaces ». Les outils archkit s'écrivent en Go : packages, interfaces et tests.

    Going, Going, Gone — le dossier d'architecture

    Un site d'enchères en ligne, conçu de bout en bout : caractéristiques, quanta, style, ADR, risques et diagrammes, plus la boîte à outils Go archkit.

    len=0 cap=2020 modules en 6 parcours, rédaction en cours

Comprendre en voyant

Les idées difficiles ont leur animation, à regarder ou à manipuler. Exemple : comment Go répartit cinq tâches sur deux processeurs, étape par étape.

Le scheduler de Godu module Concurrence
Chargement de l’animation…
Lire les 19 étapes en texte
  1. main démarre sur P0. GOMAXPROCS=2 : deux P, chacun avec sa propre file. P1 n’a encore rien à faire.
  2. go func() crée G2. Une goroutine neuve va dans runnext de P0 : la place prioritaire, pas la file.
  3. go func() crée G3. G3 prend runnext. G2 recule en fin de file locale.
  4. P1 vole du travail. P1 était à vide : il prend la moitié de la file de P0, soit G2, et l’exécute.
  5. go func() crée G4. G4 prend runnext, G3 passe dans la file locale.
  6. go func() crée G5. G5 prend runnext, G4 suit G3 dans la file locale.
  7. wg.Wait() bloque main. G1 est garée : elle attend sans occuper de P ni de thread.
  8. P0 reprend runnext. runnext passe avant la file : la dernière goroutine créée, G5, tourne en premier.
  9. G2 se termine. wg.Done() décrémente le compteur. P1 est de nouveau à vide.
  10. P1 vole encore. File de P0 : G3 et G4. P1 en prend la moitié, G3, et l’exécute.
  11. G5 est préemptée. Après 10 ms sans rendre la main, G5 est interrompue et part dans la file globale.
  12. P0 prend sa file locale. runnext est vide : P0 exécute G4, en tête de sa file.
  13. G3 se termine. P1 n’a plus rien en local.
  14. P1 lit la file globale. File locale vide : P1 reprend G5 depuis la file globale.
  15. G4 se termine. P0 n’a plus rien et rien à voler : il reste inactif.
  16. Le dernier wg.Done() réveille main. Le compteur tombe à zéro : G1 sort de l’attente et prend runnext de P1.
  17. G5 se termine. P1 se libère.
  18. main reprend sur P1. G1 continue là où elle s’était arrêtée, sur un autre P qu’au départ.
  19. main se termine. Le programme s’arrête : cinq goroutines se sont partagé deux P.

Ta progression, en clair

Niveaux, série de jours, boss en fin de module, badges. Voici un profil après quelques semaines.

Niveau 7

1 860 XP au total

310/500 XP, encore 190 avant le niveau 8

12 jours

d’affilée, au moins une action par jour

Boss du module Types composites

L’entrepôt du Black Friday

difficulté 4/5

+250 XP

  • Première leçon, obtenu
  • Premier TP au vert, obtenu
  • Une semaine pleine, obtenu
  • Module maîtrisé, pas encore obtenu
  • Trente jours actifs, pas encore obtenu

Un espace privé, un seul mot de passe.

Se connecter