Le cancer dont je parle c’est l’utilisation presque systématique qui est faite de JSP, Struts et bientôt JSF. Ce cancer, il se répand car aujourd’hui on trouve sur le marché des prestataires qui ne savent faire que ça et qui le préconisent donc presque systématiquement. La diffusion est virale, chacun se disant que vu que tout le monde fait comme ça, il vaut mieux ne pas prendre de risques et faire pareil. Le tout étant joyeusement relayé par la presse spécialisée. Le résultat de cette infection, c’est tout d’abord que Java est perçu comme une technologie complexe alors que c’est totalement faux. Le plus souvent, les applications créées sont complexes. Elles demandent des compétences multiples. Au final, le modèle et le code spaghetti, truffés d’artéfacts parasites évoluent difficilement. Mais ce qui amène cette complexité, c’est l’utilisation de ces technos (JSP, Struts, JSF) et non pas Java en soi.

Le cas de TSS est intéressant car contrairement à la plupart, ils en ont pris conscience. Ils ont réagit. Et aujourd’hui ils partagent leur expérience.

Là où l’histoire de TSS a une saveur particulière, c’est qu’il existe deux versions de TSS :

Lorsque TSS a mis en place le site dotNet, ils s’étaient dits que ça serait mal perçu d’utiliser des technos Java pour s’adresser à un auditoire de développeurs dotNet. Ils ont donc re-développé intégralement puis mis en production une plate-forme fonctionnellement identique mais en techno dotNet.

Le résultat, c’est qu’après avoir éradiqué JSP et leur architecture MVC à la sauce Struts, en voyant la simplicité et l’évolutivité offerte par la plate-forme, ils ont décidé d’abandonner la dualité des plate-formes et de n’en maintenir qu’une seule: Java !

Attention, ne le répétez surtout pas aux développeurs dotNet, TSS pourrait perdre une partie de son lectorat… ;-)

Mon but ici n’est pas d’engager une polémique Java vs dotNet (trolls s’abstenir). Je pratique d’ailleurs les deux. Je veux seulement attirer l’attention sur quelque chose qui bouleverse pas mal d’idées reçues. Java n’est pas plus compliqué que dotNet ou vis versa. Ce sur quoi je veux mettre l’accent, c’est qu’en choisissant des moutons comme architectes, les projets Java ne doivent pas s’étonner de souffrir des mêmes maux que l’ensemble du troupeau.

Revenons au cas de TSS.

Problème :

  • Une architecture à la mode Struts devenue complexe et rigide au fil du temps
  • Un code existant JSP + EJB devenu difficile à maintenir et à tester

Contraintes :

  • Une fréquentation importante du site (7 millions de hit mensuels)
  • Conserver l’essentiel du code existant
  • Maintenir la compatibilité avec les URL existantes pointant sur le contenu déjà publié.

Objectifs :

  • Améliorer les performances
  • Simplifier l’architecture pour obtenir une infrastructure évolutive facile à maintenir et à tester.

Principales solutions retenues :

  • Tapestry en remplacement de JSP et de l’architecture à la sauce Struts
  • EJB session facade + JDO en remplacement d’EJB CMP.

Je mettrais entre parenthèses le choix de JDO. Il a aussi été fait en partie pour d’autres raisons que celles que j’évoque ici. Sur le fond l’abandon d’EJB CMP est une excellente chose. Mais pour cet aspect, ils auraient tout aussi bien pu retenir Hibernate, TopLink ou attendre EJB3 par exemple et obtenir des résultats similaires. Le choix qui est vraiment déterminant dans le succès de cette opération, c’est l’usage de Tapestry en remplacement de la mayonnaise JSP pour la publication. Grâce à ça, ils atteignent leurs objectifs et se retrouvent avec :

  • Une séparation des rôles claire:
    • Des développeurs Java qui produisent des classes dont le code est centré sur les aspects fonctionnels et n’est pas pollué par l’architecture, les aspects techniques ou la présentation.
    • Des designers qui font exclusivement du HTML et en exploitent à volonté tout le potentiel sans avoir à ce préoccuper de ce que font les développeurs Java.
  • Une adhérence quasi-nulle entre les traitements et la présentation.
  • Des composants de services et de présentation réutilisables et évolutifs
  • Des classes simples, limpides et en nombre réduit
  • Une application dont la couche présentation peut être débugée en live

Voilà pourquoi depuis 2001 j’utilise Tapestry et le préconise souvent. Alors, faites comme TSS, ne soyez plus un mouton mais devenez une hirondelle.

Pour en savoir plus :

PS : Un article sur « pourquoi JSF vous conduit aussi droit dans le mur » serait peut être pas mal non plus ?