Il est temps de creuser plus loin !

Résoudre un exercice sur Exercism n’est que la première étape. Le véritable apprentissage vient ensuite !

Cette semaine, nous avons lancé le nouvel onglet « Creuse plus loin » sur les exercices, conçu pour t’aider à aller au-delà de l’étape de résolution et à explorer les nuances et les compromis d’un exercice, sans avoir besoin de demander à un mentor.

Introduction

Les solutions de nos exercices varient énormément. L’exercice « véritable » le plus élémentaire dans la plupart des parcours est TwoFer. Une solution typique ressemble à ceci (c’est du Ruby, mais c’est similaire dans la plupart des langages) :

module TwoFer
  def self.two_fer(name='you')
    "One for #{name}, one for me."
  end
end

Pourtant, parmi les 500 solutions les plus récentes qui ont passé les tests, plus de 350 étaient uniques 😲 Et même si l’on normalise des choses comme les espaces et les noms de variables, plus de la moitié restent de véritables solutions uniques.

Ce qui rend absolument fascinant d’explorer comment chacun s’y prend. Mais c’est aussi totalement irréaliste. Il y a des millions de solutions sur Exercism, et les lire toutes prendrait littéralement une vie entière.

Cependant ! Après avoir conçu les exercices et accompagné des centaines de milliers de personnes tout au long de ceux-ci, notre équipe a une assez bonne idée des différentes approches que les gens adoptent. Nous avons donc ajouté le nouvel onglet « Creuse plus loin » pour mettre en avant les différentes façons idiomatiques (ou non idiomatiques, mais intéressantes) de résoudre un exercice.

Un exemple

Prenons un exemple pour voir tout ça en action. En C#, il y a plusieurs façons d’inverser une string.

Tu peux utiliser la méthode Array.Reverse() :

var chars = input.ToCharArray();
Array.Reverse(chars);
return new string(chars);

Ou utiliser une approche plus courte, basée sur LINQ :

return new string(input.Reverse().ToArray());

ou utiliser un StringBuilder :

var chars = new StringBuilder();
for (var i = input.Length - 1; i >= 0; i--)
{
    chars.Append(input[i]);
}
return chars.ToString();

ou même adopter une approche un peu moins idiomatique (mais plus performante !) et utiliser Span<T> :

Span<char> chars = stackalloc[input.Length];
for (var i = 0; i < input.Length; i++)
{
    chars[input.Length - 1 - i] = input[i];
}
return new string(chars);

Nous appelons chacune de ces solutions une approche, et chacune possède son propre article qui l’explique. La page « Creuse plus loin » de cet exercice les réunit, et s’accompagne aussi d’un article sur la performance qui explore les compromis.

👉🏾 Jette un coup d’œil (tu devras passer en navigation privée si tu n’as pas encore résolu l’exercice)

Mais ce n’est pas tout !

En plus des documents sur ces différentes approches, il y a des milliers de vidéos produites par notre communauté, qui explorent des exercices, enregistrent des démonstrations pas à pas ou des sessions de code en direct, et plongent dans les profondeurs de ce qui fait une solution idiomatique. Nous rassemblons toutes ces vidéos pour les intégrer aux pages.

Implique-toi

Au cours des prochaines semaines, tu verras l’onglet « Creuse plus loin » apparaître sur les exercices du site.

Si tu souhaites proposer une approche, un article d’exercice, ou nous parler de tes vidéos pour que nous les ajoutions, écris à jonathan@exercism.org et il t’aidera à te lancer.

Et pour finir, dis-nous ce que tu penses et partage tes idées et tes réflexions dans le post du forum !