Les cinq lois de la programmation évolutive

Ecrire des programmes qui fonctionnent est à la portée de chacun. Surtout en Python ;). La difficulté principale est de réussir à écrire des programmes qui évoluent dans le bon sens, et éviter l'effet spaghetti*. Les cinq lois énoncées ci-dessous synthétisent les bonnes pratiques à adopter pour favoriser une croissance contrôlée des programmes.

• Les bon noms font les bons amis
• Soigne ta signature
• Ecourter les conversations
  
• Ne jamais radoter
• Diviser pour mieux régner

Les bon noms font les bons amis

Choisissez avec soin le nom de vos variables, modules, fonctions, classes et méthodes. Chacun d'entre eux doit être explicite et indiquer clairement son objectif.

Quelques pistes:

• Respectez le PEP8
• Utilisez des conventions pour les méthodes et fonctions...
• qui retournent des séquences : conjugez le nom au pluriel ou ajoutez un suffixe explicite comme 'list' (getElements, itemList, ...)
• qui renvoient un booléen: préfixez de 'is' ou 'has'
• Attention à la redondance dans les noms: les méthodes d'une classe par exemple ne doivent pas avoir un nom dont une partie du sens est donné par la classe:
• MaList.getList() -> MaList.get()
  
• RS232.rs232_read() -> RS232.read()

Soigne ta signature

Les arguments de chaque méthode ou fonction doivent également être précis. Eviter les signatures magiques avec *args et autres **kw, qui rendent les interdépendances floues.

Quelques cas particuliers:

• Les fonctions de traitement de formulaires dans la programmation web
• Les decorators appliqués sur des fonctions dont les paramètres ne sont pas connus
• Plus globalement: Les briques intermédiaires en charge de relayer des informations sans connaitre les partis

Ecourter les conversations

Lorsqu'un élément (classe, module, etc.) est utilisé dans du code, si plusieurs appels successifs sont effectués pour l'utiliser (sans ou avec peu d'interactions), ses APIs doivent être modifiées pour écourter les échanges au maximum. Le module __init__ d'un paquet est un bon outil pour synthétiser son utilisation.

Exemple de conversation trop bavarde:

from Paquet import misfit
from Paquet import cat

params = misfit.makeParams()
truc = cat.generateTruc(params)
bidule = cat.pondBiduleAvecTruc(truc)

Les apis du Paquet et de ses modules peuvent être améliorés pour obtenir:

from Paquet import pondBidule

bidule = pondBidule()

Le module __init__ joue alors le rôle d'intérmédiaire entre cat et misfit

Ne jamais radoter

L'ennemi du code est le doublon. Dès que deux blocs présentent des similitudes, il est nécessaire de les réunir.

Diviser pour mieux régner

une fonction ne devrait jamais dépasser un écran. Il est nécessaire de la subdiviser le cas écheant. Il en va de même pour les classes, modules, et paquets: il ne faut pas avoir peur de diviser son paquet en une multitudes de petits paquets.

*spaghetticus effectus: transformation d'un programme en un bloc monolithique ou chaque élément ne peut plus évoluer indépendamment des autres. Porte aussi le nom de pieuvre à 6 têtes dans la mythologie geek.