« IL », c’est l’ordinateur, bien sûr. Tentative ultime de raccrocher à une figure un peu anthropomorphisée ce qui se passe en fait dans la machine, autrement dit les programmes qui font des machins. Parce qu’évidemment, tout le monde le sait, l’ordinateur ne fait rien lui-même. Il n’est ni intelligent, ni bête, il fait ce pour quoi on l’a programmé.

Alors pourquoi, pourquoi cette impression si facilement partagée qu’il y a quand même là-dedans une sorte de volonté propre, ou pire, aléatoire (ou encore pire quand vraiment tout va mal, machiavélique)..?

Passons sur notre tendance à l’anthropomorphisme, assez récurrente, réflexe ancestral face à l’inconnu et l’incompris. S’il n’y avait que ça, il suffirait de se moquer et ça serait plié. Non non non. Il y a forcément plus.

Ce qu’il y a, c’est que les programmes qu’on utilise ont depuis longtemps dépassé le stade des micro-routines. Ils représentent parfois des millions de ligne de code, et même s’ils ont été élaborés en suivant les règles de l’art (respect des bonnes pratiques, design patterns, pizza, versionning des sources, etc), leur niveau de complexité excède grandement nos capacités d’appréhension en un seul coup d’œil, pour le dire comme ça.
En d’autres termes, ils ont franchi le seuil au-delà duquel il n’est plus possible pour quiconque de savoir ce qui va exactement se passer dans tous les cas possibles (notamment parce que ces « cas » sont trop nombreux, donc qu’on peut difficilement assurer qu’on les a tous envisagés).

Si on veut recourir à une analogie (tu es nouveau ? Cliquette ici), disons que tout programme dépasse rapidement le stade où on peut croire qu’il est un ensemble fini prévisible, pour devenir un système probabiliste gazeux.

La principale conséquence en est que l’utilisateur (et même le créateur) n’est jamais complètement certain de ce qu’il va faire. Et de quoi est-ce que c’est la caractéristique, au fond, je vous le donne en mille ? De l’altérité.

L’autre. Ce truc qui n’agit pas comme dans ma tête. Bref, sans imaginer bien sûr qu’il ait une volonté propre, le programme a suffisamment d’ « indépendance » pour se comporter comme quelque chose d’aussi imprévisible qu’un être humain, et c’est assez génial (en tout cas à titre personnel je trouve ça exaltant, mais les clients ne partagent pas toujours cet avis, bizarre…)

D’où cette belle formule, qui me sert à briller à la cafeteria ou à clore certains débats stériles : oui, les ordinateurs (en fait : les applications) sont des êtres humains comme les autres.

Et c’est pourquoi bien programmer passe principalement par l’application de bonnes pratiques qui visent à réduire au maximum les interstices où va se fourrer l’imprévisibilité, et à tester au maximum toutes les éventualités qui peuvent se présenter — ce d’autant plus que, en face de l’ordinateur, il y a un utilisateur, qui lui aussi est imprévisible, et qui comme vous l’aurez appris si vous développez, fera toujours exactement le truc que vous n’aviez pas prévu.

_________________________________

Illustration : Marvin le robot dépressif, dans H2G2 – The Hitchhiker’s Guide to the Galaxy

Résumé de l’épisode précédent : un framework, c’est une boîte à outils, des briques de base, et une méthodologie pour développer mieux, plus vite, et de manière plus sûre (un peu comme ça, quoi). Mais si ça peut fortement aider, ça n’est pas magique, et ça demande de suivre les principes du framework lui-même.

Une partie des principes méthodologiques qui va avec un framework est  couramment regroupée sous le nom de design patterns. Une fois encore, on s’abstiendra de traduire l’expression (la version française préconisée étant patrons de conception, et ça sonne un peu Bergère de France…)

Pour faire court (dans un premier temps), disons qu’un design pattern est une façon de résoudre un problème type. Il ne s’agit donc pas d’une solution en tant que telle, mais plutôt d’une recette, c’est-à-dire la description d’une manière d’opérer face à un certain type de problème.

Historiquement, la théorisation des design patterns fait beaucoup référence, et c’est une chose qui ne nous étonnera pas, au domaine de l’architecture, de l’urbanisme et de la construction, notamment suite au travaux de Christopher Alexander dans les années 70.
Constatant que la conception en architecture en particulier, mais aussi en ingénierie en général, conduisait à affronter des problèmes récurrents (isolation, solidité des structures, communication entre l’intérieur et l’extérieur…) il abstrait des archétypes destinés à couvrir tous ces aspects.

Un pattern est ainsi à comprendre comme un « modèle » éprouvé reliant une solution à un problème dans un certain contexte.

Tout problème de conception, dirait Alexander, met en jeu un seul individu face à une immensité. Ce problème contient un certain nombre de variables qui, combinées en sous-ensembles, représentent un nombre de cas débordant rapidement les capacités limitées de son cerveau.
D’où l’intérêt de diviser et de hiérarchiser ces sous-ensembles pour les étudier à part, et recourir à ce qu’on pourrait nommer le bon sens collectif de l’histoire (capitaliser sur les solutions qui ont prouvé qu’elles marchaient).
Dès ses premiers travaux Alexander met l’accent sur la nécessité de comprendre les rapports entre les parties et le tout, et de savoir comment s’y prendre pour traiter ce tout. Ce que nous avons appelé dans l’épisode précédent faire face à la complexité.

De l’urbanisme à la POO

En 1995, les quatre mousquetaires du pattern, le bien nommé « Gang Of Four », s’inspirent d’une partie de ces travaux et transposent la méthode dans la programmation orientée objet. Comme Alexander, même si la démarche est, disons, moins empreinte d’une sourde angoisse métaphysique quant à l’appréhension de l’infini, leur but est de proposer des outils conceptuels pour gérer la complexité, en l’occurrence, posée par certains problèmes récurrents en programmation.
Ils sont issus des bonnes trouvailles et des bonnes pratiques de générations de développeurs et dispensent ainsi, comme on dit souvent, de réinventer le fil à couper la roue.

J’avais commencé un paragraphe complet donnant un exemple (en choisissant le pattern bridge, un modèle assez « simple »), et j’ai renoncé, car on ne peut pas en dire grand chose sans évoquer la programmation orientée objet, que ma chère maman n’est pas censée connaître, donc qui déborde le cadre de cette page.
Je tâcherai de présenter en revanche dans un épisode prochain le MVC, un design pattern assez connu — qui est en fait, pour être rigoureux, une combinaison de patterns. Retenons juste ceci en attendant, et au risque de me répéter : il ne s’agit pas de classes ou de bouts de programme, mais de façons de structurer son modèle de données, son architecture, son application, et ultimement son code (quelque soit le langage objet).

En guise de conclusion, et pour s’éloigner définitivement d’Alexander, signalons qu’on parle aussi de temps en temps du négatif des patterns, les antipatterns.

Comme leur nom l’indique, il s’agit des façons de faire qui sont exactement ce qu’il faut éviter. On regroupe sous ce nom des pratiques hétérogènes aux noms parfois sympatoches, comme la coulée de lave (mise en production d’un code non stabilisé qui de fait devient de moins en moins modifiable, se « solidifiant » comme de la lave), l’ancre de bateau (code conservé pour des raisons « politiques », pour ne pas fâcher un développeur et/ou en se disant qu’il servira plus tard…), ou l’objet divin (méthode ou fonction servant à trop de choses, et dont on finit par ne plus trop savoir comment elle marche).
Elles sont évidemment, presque autant que les autres, utiles au développeur — qui aura toujours au début de son existence mis en œuvre, même à son corps défendant, au moins l’un d’eux, sinon presque tous.

Dans le prochain épisode, cette fois, on parlera de MVC…

___________________________________

Image du Schéma empruntée ici : http://www.simonwhatley.co.uk/coldfusion-and-design-patterns

Ce framework porte le nom de Symfony, pour des raisons expliquées ici. Jusque là, fastoche. C’est ensuite que ça se complique. Déjà, rien que le premier mot : framework. Littéralement, cadre ou structure ; dans la programmation en général, on le traduit plus précisément par « cadre d’applications ». Enfin, on le traduirait, parce qu’on ne le fait jamais, on dit toujours frèmeouorque. A compter de cette phrase, je dirai d’ailleurs « framework » sans autre forme de procès, et même sans italiques (je suis comme ça, jsuis un gueudin).

Pour commencer, donc, qu’est-ce qu’un framework ? S’il y avait une réponse simple, on se passerait de ces lignes. La difficulté majeure tient à ce qu’il y a en fait dans la définition deux dimensions principales, complémentaires mais en partie indépendantes : un framework c’est à la fois une boîte à outils et une méthodologie. Ou, si on n’a pas peur des envolées lyriques : une boîte à outils fournie avec une philosophie.

Une boîte à outils

On a l’habitude de comparer un framework à un ensemble des « briques » toutes faites qu’on peut utiliser pour son application .
Si l’analogie n’est pas trop mauvaise, elle est insuffisante, parce qu’un framework c’est plus que ça. Cela dit, l’image de « brique » convient assez bien à ce qui circule çà et là sous le nom de composants (et d’ailleurs, le monde est bien fait, car certaines parties de Symfony sont justement mises à disposition comme composants : http://components.symfony-project.org ; dingue, hein ?)

Mais revenons à l’analogie de départ, même si elle est un peu faible ; elle dit qu’un framework est à un développeur ce qu’une boîte à outils est à un bricoleur.

Sous plusieurs aspects, un framework peut effectivement fonctionner comme une boîte à outils, en ce sens qu’il propose, dans le cas de Symfony du moins, un certain nombre de trucs pour faciliter le travail, l’accélérer, voire automatiser tout ou partie des tâches qu’on rencontre lors du développement d’une application web. C’est le côté work du framework, si l’on veut.
Enfoncer un clou, à la main, c’est douloureux et très long ; avec une pierre, moins douloureux, mais pas très précis. Avec un marteau, l’outil est assez optimal – même s’il ne dispense toutefois pas de taper. En plus, ce marteau a été testé industriellement, donc a de bonnes garanties de solidité .

Dans le développement web, on ne plante pas des clous, mais il y a des tâches équivalentes qui sont répétitives, peu gratifiantes, et d’autant plus sujettes à erreur qu’elles sont répétitives et peu gratifiantes : construction de bases de données à partir de leur schéma, import de données de test, initialisation d’interfaces d’administration, exécution de tests, gestion du cache, des urls…

Pour tout ça, le framework offre marteaux et tournevis, voire dans certains cas pistolets à clous. Ces « utilitaires »,  testés et mis à l’épreuve du feu par de nombreux développeurs, ont bénéficié de leurs retours d’expérience, leur efficacité et stabilité sont assurées par ce processus. Mais pas plus qu’un marteau ils ne dispensent pas de taper. Vous pouvez vous procurer une belle boîte à outils, ça ne fixera pas pour autant vos étagères au mur …

A un niveau un peu plus complexe, le framework (du moins Symfony) favorise l’intégration en deux coups de cuiller à pot de plug-ins, qui sont un peu comme les briques évoquées plus haut. Il en existe un grand nombre, pour des fonctionnalités plus ou moins évoluées (authentification, gestion de médias, de contenu…). On dépasse là le cadre de la « boîte à outils », et on est plutôt sur des objets de base qui font gagner du temps. C’est comme acheter des planches déjà découpées plutôt que de les scier soi-même. Mais ces objets conviennent rarement tels quels . Il faut les adapter à ses besoins. Par exemple peindre ses planches de la couleur qui va bien, choisir combien on en pose, à quelle distance les unes des autres…

Point crucial : dans le cas du framework, l’adaptation sera grandement facilitée par la méthodologie qui doit avoir été respectée par les créateurs des plug-ins. C’est-à-dire : si elle a été respectée.

Ce qui nous fait une transition toute trouvée pour le second aspect, non des moindres, de la définition d’un framework : en plus d’être une boîte à outils, un framework, c’est une façon de travailler.

Une méthodologie

Pour tenter une analogie, disons qu’un framework est à la programmation ce que grammaire et orthographe sont à la pensée.

On quitte là le champ lexical du bricolage pour celui de la linguistique, ou plutôt de l’apprentissage du langage . Glissement qui semble tout indiqué, puisqu’on parle de langage de programmation. Si on fouille un peu, on verra même que la nécessité de changer de champ répond en fait à une exigence interne, dictée par le caractère spécial des langages artificiels : un croisement génétique, pour ainsi dire, entre de la logique (qui se veut mécanique et déterministe) et de la pensée (qui reste inductive et poétique par nature, mais c’est une autre histoire).

Filons la métaphore. Quand on se met à programmer, on apprend une syntaxe, des fonctions, des mots-clés… ; bref, une sorte de grammaire et de dictionnaire .
Mais connaître par cœur l’intégral de la phpdoc ou autre n’a jamais fait un bon développeur, pas plus que réciter le Bescherelle n’a fait un grand auteur.

C’est là que, tel un cavalier qui surgit hors de la nuit (mince, ça y est maintenant j’ai la musique de Zorro dans la tête), intervient le framework. Il joue un rôle à la croisée de la rhétorique, de la littérature et de la logique :

• il énonce des conventions d’écriture et d’organisation destinées à rendre plus efficace, en homogénéisant et clarifiant
• il s’inspire des bonnes pratiques déjà existantes, notamment en termes de style
• il structure et favorise la discipline du code produit, et son indépendance à l’égard de toute solution logicielle ou matérielle.

En gros, il joue son rôle de « cadre » et de structure. C’est le côté frame du framework : il contraint à un certain nombre de choses, mais pour mieux libérer le processus intellectuel, en particulier en l’affranchissant des routines chronophages, et en aidant, par la clarté exigée, à faire face à l’augmentation de la complexité .

Si tout développeur qui connait un tant soit peu un langage (PHP en particulier, qui est plus facile d’accès que d’autres) est capable, même en tâtonnant, de mettre au point une application plus ou moins évoluée, l’expérience montre toutefois que son degré d’instabilité croît alors exponentiellement à la mesure de sa complexité, et que son code a tendance à devenir incompréhensible (et donc instable, indébuggable, non maintenable, etc…)

Pour faire face à la complexité, il faut être équipé de certains outils, intellectuels cette fois. Un framework a pour but de fournir de tels outils facilitant la modélisation des objets, de leurs relations, et des solutions aux problèmes posés. Il est à la fois une extension du vocabulaire du développeur et un perfectionnement de ses capacités grammaticales.
Du moins, il peut l’être. Car comme le marteau ne tape pas tout seul, le framework ne pense à la place de personne. Pire, comme un marteau, mal utilisé, il peut faire mal. Et s’il tend à structurer, il n’oblige ultimement personne à suivre sa méthodologie ; s’il peut aider à discipliner, il ne remplace pas l’auto-discipline qui est du ressort de ceux qui conçoivent et écrivent le code. Bref : un framework ça n’est pas la pierre philosophale qui changera votre code de plomb en or.

On se résume : côté pile, le framework est un cadre structurant, côté face, le framework est un outil facilitant le travail.
Finalement, on avait bien raison de garder le mot anglais.

Dans le prochain épisode, on parlera de design patterns…