Un parcours Exercism complet dispose de deux types d'exercices : les exercices d'apprentissage et les exercices d'entraînement. Ils sont fondamentalement différents et se complètent bien.
Les exercices d'apprentissage d'un parcours sont des exercices conçus pour enseigner des concepts individuels qui constituent la base d'un langage de programmation donné. Ces concepts forment un programme.
Cette documentation contient des pistes et des conseils pour concevoir avec succès un programme pour ton parcours.
L'objectif d'un programme
Le but final d'un programme est d'amener les apprenants à être à l'aise pour lire et écrire du code idiomatique dans le langage cible.
Chaque exercice d'apprentissage pris individuellement est très ciblé. C'est un pas petit et très précis qui fait avancer l'apprenant vers la compréhension d'un aspect du langage. Il ne s'appuie que sur des concepts introduits auparavant.
En résolvant l'exercice, l'apprenant commence à se familiariser avec le concept. La compréhension vient avant tout par la pratique, bien moins par les explications. Le contenu explicatif est là pour introduire auprès de l'apprenant les idées dont il a besoin pour résoudre l'exercice (d'où le choix du nom de fichier : « introduction.md »).
On veut permettre aux apprenants de commencer à écrire du code immédiatement, sans avoir à tout comprendre dès le départ. Pour y parvenir, on passe volontairement sous silence certains détails et on laisse beaucoup de choses inexpliquées. On simplifie et on fournit des squelettes de code là où c'est possible. Cela réduit la charge cognitive du démarrage et laisse le temps et l'espace nécessaires pour que les connaissances s'ancrent. Cette approche ne signifie pas que l'apprenant n'a pas besoin de savoir ces choses, mais qu'il n'a pas besoin de les savoir pour l'instant.
Souvent, les tout premiers exercices doivent contenir du code non idiomatique. C'est parce qu'au début, la plus grande partie du langage est encore inconnue de l'apprenant, et que la plupart des concepts n'ont pas encore été introduits. En autorisant du code non idiomatique dans les tout premiers exercices, on permet aux apprenants de faire beaucoup de petits pas en terrain familier plutôt que quelques grands pas en terrain inconnu. Résultat : ils atteignent plus vite le stade du code idiomatique, et avec moins de friction.
Structure de base
Les exercices sont organisés sous forme d'arbre, avec un exercice d'introduction au sommet comme point de départ. Les exercices suivants enseignent des concepts qui supposent d'avoir compris des concepts enseignés plus tôt.
Portage et emprunts
Il peut être utile de regarder comment d'autres parcours d'autres langages ont construit leurs exercices d'apprentissage. Tu peux trouver des exemples d'exercices d'apprentissage issus d'autres parcours de langages ici.
Cela dit, si tu décides d'utiliser d'autres exercices comme point de départ pour les tiens, veille à ce que l'exercice obtenu porte bien sur le concept tel qu'il existe dans ton langage. Les concepts diffèrent parfois subtilement, parfois radicalement. Parfois, ils n'existent pas du tout dans d'autres langages.
Le programme, et donc l'arbre des concepts, doit représenter les concepts qui existent dans ce langage précis.
N'ajoute pas de concepts simplement parce que d'autres parcours le font.
Dans certains cas, il peut être tentant d'ajouter un concept parce que les gens doivent souvent le contourner en utilisant des concepts qui, eux, existent. Plutôt que de faire cela, introduis le concept que le langage utilise réellement, et envisage d'ajouter un exercice qui explique comment l'utiliser dans ce type de situation.
Par exemple, il n'y a pas d'énumérations en Go. À la place, l'arbre des concepts de Go introduit les constantes, et enseigne comment les utiliser dans le type de situation où tu utiliserais des énumérations dans d'autres langages.
Demander de l'aide
N'hésite pas à demander de l'aide. Il vaut mieux poser la question dès le début ou pendant que tu travailles sur un exercice, plutôt que d'en discuter pendant la revue de code.
Sur GitHub, tu peux mentionner l'équipe @exercism/learning-mode.
Sur le forum Exercism, ouvre une issue dans la catégorie Exercism Support.
Pour commencer
Notre expérience nous a appris que la façon la plus pragmatique de développer un programme est de faire grandir l'arbre des concepts de façon organique, en commençant par les concepts les plus simples. On n'a pas besoin de tout concevoir à l'avance, et il est d'ailleurs généralement utile de ne pas regarder trop loin.
On commence par le strict minimum de concepts, ceux qui sont les plus fondamentaux pour écrire quoi que ce soit dans le langage. On essaie aussi de commencer par les concepts les plus familiers pour le développeur moyen. Le familier, c'est bien. Le familier, ce n'est pas déroutant.
Rappelle-toi que si le but final est d'écrire du code idiomatique, les étapes qui y mènent ne sont pas toujours idiomatiques. Utiliser ce qui est familier, même si ce n'est pas un excellent exemple de code dans ce langage, aide l'apprenant à avancer plus vite vers l'objectif d'un code plus typique du langage.
Développe le premier exercice
Plutôt que d'essayer de cartographier tout l'arbre des concepts à l'avance, commence simplement par le premier exercice. Le but du premier exercice est de permettre à l'apprenant de commencer à apprendre avec le moins de friction possible. Il fait là son tout premier pas vers la familiarisation avec l'apparence du code dans ce langage. Il écrira peut-être un petit bout de code, ou peut-être juste quelques ajouts à un squelette pour terminer l'exercice. Les apprenants ont déjà résolu « Hello, World! » pour accéder à cet exercice. Mais dans « Hello, World! », ils ne changent que le texte. Toute la syntaxe du langage peut encore leur être inconnue. Essaie d'optimiser pour une victoire rapide, et pour que les apprenants se familiarisent suffisamment avec les rudiments de la syntaxe pour avancer en confiance.
Pour en savoir plus sur le développement du premier exercice.
Les exercices suivants
Le premier exercice doit déverrouiller une poignée d'exercices qui introduisent des concepts fondamentaux. Ce seront par exemple les primitives ou les types de base et les opérations simples sur ces types.
Pour en savoir plus sur le développement des exercices suivants.
Et ensuite ?
C'est là que ça devient souvent intéressant. Il y a tellement de choses que tu pourrais introduire à ce stade. Comment décider quels concepts aborder ensuite ?
Cela n'a en fait pas grande importance. Tant que tu commences quelque part qui semble raisonnable, tout ira bien.
Pour en savoir plus sur ce que nous entendons par « raisonnable » dans le contexte de l'extension de l'arbre des concepts.
Ne convertis pas les exercices d'entraînement
Un bon exercice d'apprentissage est extrêmement ciblé, et n'enseigne idéalement qu'un seul concept. Il n'y a généralement qu'une seule approche attendue pour le résoudre. C'est l'inverse des exercices d'entraînement, qui sont ouverts et se prêtent à l'exploration.
Un bon exercice d'apprentissage est généralement un mauvais exercice d'entraînement, et inversement. Comme les objectifs des exercices d'entraînement et des exercices d'apprentissage sont complètement différents, on ne transforme pas des exercices d'entraînement en exercices d'apprentissage. On écrit tous les exercices d'apprentissage à partir de zéro, ou on les base sur des histoires conçues explicitement pour enseigner des concepts simples.
On encourage à faire l'impasse
Parfois, tu auras l'impression d'être face à un blocage. Le concept A suppose de comprendre le concept B, et le concept B suppose de comprendre le concept A.
Dans ce cas, simplifie. Fais l'impasse sur une partie de la complexité de l'un pour que les apprenants se familiarisent avec l'autre. Il est parfaitement acceptable de dire que quelque chose sera approfondi plus tard, et que pour l'instant l'apprenant n'a besoin de comprendre que ce petit bout.
Les concepts se comprennent plus profondément par étapes et avec le temps.
Choisir des histoires
Un exercice d'apprentissage a toujours une histoire.
Si tu reprends un exercice d'un autre parcours, l'exercice aura déjà une histoire. Dans ce cas, tout est prêt.
Pour voir s'il existe des histoires que tu peux utiliser ou des exercices que tu peux forker, consulte la liste des histoires.
Si tu as un concept mais pas d'histoire, notre recommandation est d'écrire un petit exemple de code simple qui utilise le concept que tu introduis. Puis de construire l'histoire à rebours à partir du code. Garde l'histoire d'une simplicité enfantine. Pas besoin que ce soit de la bonne fiction. Pas besoin d'une intrigue forte ni d'un développement des personnages. Elle peut tenir en deux lignes.
Échange tes idées d'histoires avec l'équipe Exercism. On a beaucoup d'expérience dans la création d'histoires adaptées.
Une fois que tu as une histoire, il te faudra sans doute ajuster un peu le code pour qu'il colle à l'histoire.
Contributions de la communauté
Travailler sur un programme implique deux activités distinctes mais entremêlées :
- Conception du programme : choisir et ordonner les concepts
- Mise en œuvre des exercices : écrire la documentation et créer les exercices pour enseigner ces concepts
On a constaté qu'il est à la fois amusant et enrichissant de faire contribuer la communauté élargie à la mise en œuvre des exercices. La conception du programme elle-même, en revanche, est plus facile à mener avec une petite équipe de contributeurs qui construisent tous ensemble une compréhension du programme complet et de ses subtilités.
Cela dit, on recommande que l'équipe de conception du programme mette en œuvre les cinq ou six premiers concepts avant d'ouvrir aux contributions de la communauté. Cela aide à garantir que les membres de l'équipe de base comprennent eux-mêmes le processus avant d'avoir à relire les pull requests venues de la communauté au sens large.
Il est aussi plus facile de créer des issues pour ces concepts d'ordre supérieur, et c'est généralement plus amusant pour les membres de la communauté de travailler dessus, car il y a moins de contraintes à prendre en compte.
Créer des issues
On n'a toujours pas trouvé la meilleure façon de créer des issues pour créer des exercices d'apprentissage.
Dans certains parcours, on a essayé de créer des issues distinctes pour le concept et pour l'exercice. Dans d'autres, on a essayé des issues contenant une liste de points à cocher. Globalement, on trouve que cela reste trop intimidant, et on aimerait trouver une meilleure façon de faire.
Parle-nous du processus dès que tu commences à créer des issues, et on fera de notre mieux pour t'aider à trouver comment avancer.
On mettra la documentation à jour à mesure qu'on découvrira de meilleures façons de s'y prendre.
