On n'avale pas le saucisson, on le coupe
Bien sûr ! C'est évident ! Aucune personne raisonnable (et normalement constituée) n'aurait l'idée d'avaler un saucisson. Non, on le coupe en tranches pour le manger plus facilement (voire même pour le manger tout court).
La même logique s'applique aux projets logiciels : on découpe la complexité. Si la perception de ce qu'il faut accomplir est trop considérable, on ne tente pas de s'y attaquer : on découpe. Rien ne sert de tenter une conception alors que les difficultés se multiplient.
Par exemple, si on veut développer une calculatrice graphique ayant la possibilité de tracer la BAT-équation, il serait sans doute judicieux de commencer par implémenter des fonctions simples (addition, soustraction) et de valider leur fonctionnement. On ajoute des opérations complexes (multiplication, division) et on valide à nouveau que l'ensemble fonctionne. On complète avec les polynômes, les racines carrées et on valide à nouveau. Lorsqu'un ensemble suffisant et cohérent fonctionne de manière éprouvée, on peut y ajouter l'aspect graphique. Vouloir s'attaquer à ce problème (pourtant relativement simple) en une seule étape, c'est tenter d'avaler un saucisson.
Pour plus de plaisir, on coupe des fines tranches
Les professionnels le conseillent : pour savourer le saucisson, il faut le couper en fines tranches. Et pour cela, surtout n'utilisez pas la hache, il y a des couteaux spécialement conçus pour le saucisson.
Pour le logiciel également des outils sont spécialement conçus pour mettre en œuvre simplement et facilement ce découpage : bibliothèques, classes, fonctions, fonctions inline (dans les langages C, C++ par exemple), etc. Nous avons donc à notre disposition des outils permettant des coupes de différentes épaisseurs, adaptées à chaque niveau de complexité. Cette façon de développer du logiciel en séparant les concepts compliqués n'est ainsi pas limitée aux projets conséquents. Même dans ce qui peut sembler évident (par exemple des fonctions), il convient de se demander si l'on ne peut pas découper une complexité apparente (par exemple en deux fonctions faisant des opérations simples quitte à mettre l'une d'entre elles en inline).
Conclusion
Malheureusement, beaucoup oublient cette règle de bon sens dans le cadre de leurs développements. Cela génère chez eux insatisfaction, découragement et finalement les conduit à abandonner le projet. Si vous n'y croyez pas, jetez donc un coup d'oeil sur le forum Arduino pour vous rendre compte du nombre de projets arrêtés pour cette raison.
Ne soyons pas de ceux qui tentent d'avaler un saucisson en entier. La complexité est inhérente à notre métier mais elle n'est pas forcément nécessairement malsaine. Comme pour déguster un excellent saucisson, découpons-la en fines tranches tout au long de la conception et de l'implémentation. Non seulement nous n'abandonnerons pas nos projets mais en plus nous nous régalerons à les développer.
