Un code n'est pas écrit pour être optimal mais d'abord pour répondre à ses besoins
Illustration par six profils de développeurs

Le , par Victor Vincent, Chroniqueur Actualités
Pour les professionnels du domaine du développement logiciel, écrire du bon code nécessite de respecter certaines règles, certaines conventions, certaines bonnes pratiques. Un code qui est mal documenté voire pas du tout, un code qui n'est pas modulaire est souvent considéré par le commun des programmeurs comme étant du mauvais code. Cependant, dans bien des situations, ces critères se voient être relégués au second plan. Aussi, voici six profils de développeurs qui ont écrit des codes pour gérer une suite de Fibonacci.

Développeur 1 : L'étudiant débutant

Le premier de la liste est le débutant en programmation, pour le meilleur code qui puisse être est un code récursif. Il applique ce que le prof lui a appris en classe. Son code n'est pas destiné à d'autres programmeurs et peut être lui même ne va jamais le réutiliser. Il ne se fatigue donc pas à commenter son code ou à produire de la doc.


Développeur 2: Le programmeur au Hackaton

Pour lui l'objectif c'est de réussir à faire une bonne démo. Il se contente d'une simple structure conditionnelle pour s'assurer que son code prend en compte tout ce qui était prévu dans le cadre de sa démo; de toute façon ce n'est pas le code qui intéresse le public ou le jury mais plutôt le résultat qui s'affiche à l'écran.


Développeur 3: le programmeur dans une startup

Le troisième type de développeur quant à lui est indécis dans son code, il hésite encore quant au fichier devant contenir code. La plus grande partie de son code est à écrire, un jour peut être, si l'entreprise fait long feu. Il a autant de TODO dans son code que de nouvelles idées qui lui passent par la tête. Il ne va pas se fatiguer à les implémenter avant d'obtenir le premier financement de qui voudrait bien croire et financer son projet.


Développeur 4: le programmeur dans une grande compagnie

Le quatrième est un parano du code bien documenté et tout aussi customisé. Il prend le soin de décrire la moindre variable utilisée dans le code et surtout veille à utiliser ses propres types redéfinis pour plus de sécurité. Il s'assure ainsi que personne ne pourra réutiliser son code ailleurs que dans sa boite mais aussi et surtout il montre à son chef qu'il est un bon petit disciple qui respecte toutes les règles.


Développeur 5: le programmeur Docteur en Maths

L'avant dernier de la liste lui, est un pro des fonctions, son code doit être le plus modulaire possible. Il veut que son code reflète toutes les étapes de son raisonnement quant il résolvait le problème dans son brouillon. Il écrit donc des fonctions pour chaque partie ou sous partie, pour la lisibilité, c'est déjà ça.


Développeur 6: Tom le chat

Il se moque de la suite de Fibonacci et de tous les problèmes qui peuvent préoccuper les autres programmeurs. Il se contente lui de faire en sorte de garder ses chatons ensemble. Il ne connait qu'un seul commentaire quel que soit la portion de code qu'il veut commenter, et pourtant il n'est pas le pire programmeur de la liste.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
                    public static final int UNIT = 1 ; 
                        public static final int UNITED = 2 ; 
                        //meowwwwwwww meow 
                        public int meow(int KITTENS_OF_THE_WORLD) { 
                            //MEOW 
                            if (KITTENS_OF_THE_WORLD < UNITED) { 
                                return KITTENS_OF_THE_WORLD ; 
                            } else { 
                                 //meowwwwwwww 
                                 //meowwwwwwwwwwwwwwwww 
                                 return meow(KITTENS_OF_THE_WORLD - UNIT) 
                                    + meow(KITTENS_OF_THE_WORLD - UNITED)  ; 
                            } 
                        }     

Source : Imgur

Et vous ?

Selon vous, quel est le meilleur code présenté par ces 6 profils de développeurs ?

Pensez-vous qu'un code se doit avant tout de répondre à un besoin ?

Voir aussi

Forum Humour Informatique

la Rubrique Humour


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :


 Poster une réponse

Avatar de Auteur Auteur - Expert éminent https://www.developpez.com
le 04/10/2015 à 12:46
Tu as oublié de posté le code du chat (le plus important de tous quand même) ?
Avatar de Victor Vincent Victor Vincent - Chroniqueur Actualités https://www.developpez.com
le 04/10/2015 à 13:22
Citation Envoyé par Auteur  Voir le message
Tu as oublié de posté le code du chat (le plus important de tous quand même) ?

En fait je ne peux ajouter que 5 images apparemment, le code du chat est la 6ème image.
Mais je confirme, c'est le plus important en effet
Avatar de Auteur Auteur - Expert éminent https://www.developpez.com
le 04/10/2015 à 16:00
Par contre, je crois qu'il y a une petite erreur :
Code : Sélectionner tout
int KITTENS_OF_THE_WORLD
ce n'est pas plutôt un unsigned long?
Avatar de Haseo86 Haseo86 - Membre éclairé https://www.developpez.com
le 05/10/2015 à 22:11
Mouais... l'idée est amusante, mais les commentaires sont assez condescendants, c'est dommage.
Avatar de Jipété Jipété - Expert éminent https://www.developpez.com
le 05/10/2015 à 22:43
Citation Envoyé par Victor Vincent  Voir le message
Un code n'est pas écrit pour être optimal mais d'abord pour répondre à ses besoins

Un code a des besoins qui lui sont propres ? Je serais curieux de savoir lesquels...
Avatar de LSMetag LSMetag - Membre expert https://www.developpez.com
le 05/10/2015 à 22:59
C'est marrant comme article ^^

Alors, même si je suis un développeur expérimenté, ayant travaillé dans plusieurs grosses boîtes, je suis plutôt comme l' "étudiant débutant" du premier exemple.
J'essaie toujours d'avoir le moins de code possible, pour favoriser la lisibilité, et par feignantise aussi. Par contre, je commente pas mal et surtout, je réfléchis (parfois trop je l'admets) ^^.

Il m'arrive rarement de mettre des propositions dans le code, car les décideurs ne codent pas.

J'essaie aussi de décomposer le code le plus possible, pour structurer et éventuellement réutiliser, mais je ne suis pas maniaque non plus à ce niveau là.

Donc en gros :

1) et 5), mais en modéré. Efficace pour l'évolutivité et la maintenabilité. Par contre, ce n'est pas forcément le plus productif. Mais bon, en informatique, les 35h on ne connaît pas.
Avatar de DonQuiche DonQuiche - Expert confirmé https://www.developpez.com
le 05/10/2015 à 23:10
Je ne suis pas fan de Haskell mais il a des atouts indéniables...

Code : Sélectionner tout
1
2
3
fib 0 = 0 
fib 1 = 1 
fib n = fib(n-1) + fib(n-2)
Avatar de emazoyer emazoyer - Membre à l'essai https://www.developpez.com
le 05/10/2015 à 23:38
En effet toutes les méthodes proposées sont en O(en).
Ce qui est cher payé.

Les codes précédents demandent 2.269.806.339 appels à fibonacci pour calculer fibonacci(45)=1134903170.
Cet algorithme en demande 87 (pour le même résultat, il va de soi).
C'est la Mémoïsation.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
long fibonacci(int x) { 
    if(x<0) { 
        throw new IllegalArgumentException("x="+x+" < 0"); 
    } 
    // Création du tableau de mémoïsation 
    long[] farray = new long[x]; 
    // Initialisation du dit tableau, avec un décalage de 1 car en informatique les tableau commence à l'index 0. 
    farray[0]=1; 
    farray[1]=1; 
    // Appel au calcul avec un décalage de 1 (voir ci-dessus) 
    return fibonacciRecursivity(x-1,farray); 
} 
     
long fibonacciRecursivity(int x, long[] farray) { 
    if(farray[x]==0) { 
        farray[x] = fibonacciRecursivity(x-1,farray)+fibonacciRecursivity(x-2,farray); 
    } 
    return farray[x]; 
}
Quand à l'occupation mémoire :
  • fibonacci(164)=7278316983633677837,
  • fibonacci(165) dépasse un entier signé sur 64 bits,

donc au plus nous pouvons calculer 164 valeurs.
Un tableau de 164 long n'est pas cher payé .
Nous pouvons aussi remplir tout au début le tableau des 164 valeurs (325 appels) puis avoir un temps de calcul en O(1) pour le reste du temps.
Avatar de fcharton2 fcharton2 - Membre averti https://www.developpez.com
le 05/10/2015 à 23:39
Citation Envoyé par DonQuiche  Voir le message
Je ne suis pas fan de Haskell mais il a des atouts indéniables...

Code : Sélectionner tout
1
2
3
fib 0 = 0 
fib 1 = 1 
fib n = fib(n-1) + fib(n-2)

A la syntaxe près, c'est quasiment le même code que l'étudiant débutant (si on le nettoie un tout petit peu), non?

Pour le docteur en maths, on peut faire nettement mieux que la formule de Binet. Les termes de la suite de fibonacci sont les coefficients du développement en série entière de x / (1-x-x^2). En J, c'est 5 opérateurs...

Code : Sélectionner tout
(%-.-*:)t.
Ca se lit "inverse de (%) 1-x (-.) - (-) x^2 ( x: ) en Taylor (t.)"

@emazoyer : la formule de Binet (la solution du docteur en maths de l'exemple, si on oublie le calcul de la multiplication et de la puissance comme des additions déguisées...), n'est pas exponentielle, mais O(1): on écrit Fib(n)= floor(Phi^n/sqrt(5)), (en pratique il n'y a pas besoin de la seconde partie de la formule) et ça coute tout au plus une exponentielle. C'est plus rapide qu'un calcul direct avec mémoisation (qui est O(n))

Francois
Avatar de emazoyer emazoyer - Membre à l'essai https://www.developpez.com
le 06/10/2015 à 0:51
@fcharton2
Tout à fait, mea culpa, j'ai oublié l'option prof de math dans ma remarque.

Math : O(1).
Mémoïsation simple : O(n)
Mémoïsation à l'initialisation : 325 appels à l'intialisation puis 1 opération pour chaque appel (difficile de faire mieux ).

Je voulais simple indiquer que tout appel consécutifs à des méthodes utilisant les mêmes calculs devrait interpeler tout informaticien.
Dans ma vie d'informaticien j'ai amélioré un export d'une heure en export de 2 mn en transformant une méthode en O(n3) en O(n).
Et sans modifier l'algorithme en soi (cas du mathématicien), simplement en évitant l'oubli des valeurs déjà calculées.
Contacter le responsable de la rubrique Accueil