Maintenance des logiciels: Java, le nouveau Cobol ?

Un post de Nicolas Martignoles a récemment attiré mon attention sur un article comparant les coûts de maintenance des logiciels en fonction des langages

L’article évoque en substance des coûts élevés pour les applications Java (un facteur 4,3) par rapport aux applications Cobol. Le tout basé sur une étude de 745 applications. C# semble nager dans les mêmes eaux que Java (cela semble logique). Pire: C++ semble mieux loti que Java ! J’aime bien le C++, mais cela devient franchement troublant.

En réalité l’étude fait état d’une réalité sous-jacente bien différente.

La maturité d’une application est un facteur important !

Eh oui, une application “neuve” n’est pas forcément la meilleure sous seul prétexte qu’elle a été écrite à partir d’une feuille blanche ! Cette application est surtout plus “verte”. Je pense qu’il y a différents facteurs jouant sur l’aspect maturité:

  • Une application mature est souvent plus stable. On passe au bout d’un certain temps de demandes de changements de type évolutif à des correctifs ou de ajustements liés à des conditions d’utilisation métier qui ont évolué. Ce facteur va dans le sens d’une maintenance moins chère. Hélas ce facteur de stabilité est aussi souvent le signe d’une transition de l’application vers une phase de fin de vie.
  • Un refactoring applicatif intégrant une flexibilité liée aux évolution. Au delà du design initial d’une application parfois liminaire, les changements demandés sur une application peuvent amener les développeurs à raffiner la conception pour en rendre les changements moins douloureux. Cette approche va souvent de pair avec une amélioration de la couverture de tests. Cela ne concerne hélas qu’une minorité d’application car elle nécessite des développeurs chevronnés sensibles à ce facteur. La majorité des applications se trouve plutôt dans la seconde catégorie.
  • Une entropie des applications suite à des modifications / corrections successives. les applications qui ne sont pas vraiment sous contrôle en terme de tests ont tendance à faire l’objet de “patch”, de correctifs dits chirurgicaux sans en raffiner la conception. Au contraire cela augmente la fameuse “entropie du logiciel”, c’est à dire une dégradation de son design qui augmente la crainte des développeurs d’y toucher, augmentant à son tour les pratiques accélérant l’entropie du logiciel ! Cette spirale se termine finalement par une sclérose totale du code conduisant à la réécriture complète de celui-ci.

L’expérience des développeurs

L’article insiste à juste titre sur les pratiques managériales privilégiant une équation économique court terme. En clair: on embauche des développeurs inexpérimentés à bas salaires pour réduire les coûts. Advienne que pourra de la maintenance ultérieure !

Effectivement les équipes de développement Java sont des équipes jeunes. Il est rare d’y croiser des développeurs de plus de 10 ans d’expérience. On parle déjà de développeur sénior pour des jeunes ayant 5 ans de pratique professionnelles dans les pattes. Il est vrai que le développeur armé de 15 ans d’expérience est d’une part plus cher que son homologue Coboliste et d’autre part qu’il cherchera plutôt une position d’architecte, de team leader ou d’expert technique. Nous avons là deux cultures différentes.

En contrepartie, il n’existe probablement plus de développeur Cobol débutant. Il ne faut pas se leurre, Cobol n’est probablement pas le language le plus sexy, mais la communauté des développeurs n’est pas nécessairement formée d’idiots (en fait, il y a probablement la même proportion d’idiots chez les Cobolistes que chez les Javanais) et les 20 ou 30 ans d’expérience de ces développeurs s’ils ne sont pas un facteur linéaire de compétence les aident produire du logiciel de qualité.

java le nouveau  Cobol ?

Java est le langage majeur des nouvelles applications de gestion. Il absorbe une quantité très importante de la profession avec une disparité de qualification très importante et globalement une population peu expérimentée. A ce titre, il ressemble à ce qu’était Cobol dans les années 80. Il est d’ailleurs devenu un lieu commun de dire que Java est le Cobol des années 2000 (ou 2010 maintenant). L’article avance sans doute avec raison l’existence d’une population importante de développeur Java sans formation solide. C’est aussi ce que j’ai pu voir en entretien de recrutement.

Et C++ ?

Je persiste à dire que C++ a un coût de développement, donc de maintenance potentiellement plus élevé que Java:

  • Le langage est difficile, beaucoup plus difficile et piégeux.
  • Le langage est de bas niveau et ne possède pas l’écosystème de librairies et frameworks s’assemblant rapidement pour adresser certaines problématiques. Pour ne pas parler des outillages et de la communauté open-source…

Mais voilà, beaucoup de développeurs “moyen” ont déserté C++ dans les années 2000, la population C++ est essentiellement constituée de développeurs aguerris, expérimentés sur le langage, voir d’amoureux de ce langage ! Bref la communauté s’est professionnalisée ! Il n’est pas étonnant de constater que la qualité des conceptions et du code produit en C++ soit supérieure, moins sujette au bugs. Cela n’a rien à voir directement avec le langage, mais avec la communauté.

Un jour peut-être…

L’article est trompeur sur son affirmation, mais pas sur son contenu. Les deux facteurs premiers avancés sont réels:

  • Réécrire sans cesse les applications n’est pas une solution. Une application “verte” est toujours plus baguée. De bonne pratiques de maintenance incluant une couverte de tests unitaires et une utilisation agressive du refactoring étendent de manière très importante la durée de vie des applications jusqu’à leur réelle obsolescence technologique (au lieu de la limite de sclérose).
  • L’expérience et la compétence sont des facteurs clé. Ils prédominent largement les aspects de contexte technologiques. On le sait depuis longtemps, mais le management classique reste imperméable à ces assertions.

Ma conclusion n’est pas que Java est un mauvais langage. Sans doute en existe-t-il de meilleurs et je sais qu’il il y en a de moins bon. En fait, peu importe. Je conclue surtout que les valeurs agiles et le Software Craftmanship vont dans la bonne direction: du logiciel de qualité développé avec rigueur et compétence.

Qui a peur du Lightning Talk ?

Le Scrum Day 2012 propose, parmi ses formats de soumissions, le “lightning talk”. C’est une nouveauté et un principe simple : vous avez 5 à 10 minutes pour présenter votre sujet.

Je trouve le format attractif, aussi vais-je moi-même proposer un sujet selon ce format.

Plus simple ?

D’abord le format est attractif car il vous permet de ne préparer un sujet que pour 5 à 10 minutes. C’est en principe moins stressant que faire cet exercice pour 45 minutes ! On verra plus loin que ce n’est pas entièrement vrai.

Focus, focus …

Dans une session de 45 minutes, on a tendance à cibler un sujet, puis à explorer différentes facettes de celui-ci. Certes, on a ainsi la sensation d’avoir traité le sujet, mais n’il y a-t-il pas un aspect prédominant par rapport à un autre ? Si c’est le cas (et c’est souvent le cas) celui-ci sera finalement perdu au sein d’une présentation assez longue. Dommage !

ma proposition et mon challenge sont ainsi celui-ci: ne choisir qu’un aspect et un seul. N’aborder que celui-ci, être direct, pertinent et percutant sur ce sujet ciblé ! C’est ce que je vais essayer de faire !

Le sens de l’info

Cette idée du lightning talk (je dois l’avouer, j’ai posé à ce que ce format soit proposé) m’est venue en écoutant une émission de France Info: le sens de l’info, avec Michel Serre. Dans cette émission, Michel Serre évoque un sujet durant 6 minutes environ. Je ne cesse d’être surpris par la masse de réflexions et d’informations que Michel Serre parvient à délivrer dans un temps si court !

Certes je ne suis pas Michel Serre, mais pourquoi donc aurais-je besoin de 45 minutes pour délivrer un message moitié moins consistant. “less is more” disait Ludwig Mies (et Steve Jobs après lui). Il est temps pour moi de montrer que j’y croie

Aller à l’essentiel

J’ai un constat un peu amère à faire: j’ai assisté à de nombreuses présentations et pour une grande proportion d’entre elles j’en suis arrivé à la conclusion que le message ou l’information délivrée aurait pu l’être dans un format bien plus court !

C’est ici que l’apparente simplicité du format se transforme en réelle difficulté: comment éliminer le superflu ? Que faut-il couper pour ne pas diluer le sujet initial ?

L’exercice n’est pas facile, il sera (presque) nouveau pour moi.

Et vous, pourquoi ne présenteriez-vous pas un “lightning talk” au Scrum Day ?

Pour en savoir plus sur les Lightning Talks

  • L’article de Wikipedia dédié au sujet
  • Les Pecha Kucha sont un format très particulier de Lightning Talks en 20 minutes et 20 slides.
  • La conférence Ignite vous donnera aussi de nombreux exemples de Lightning Talks en format court (5 mn).

Note de lecture : Ship it ! A practical Guide to Successful Software Projects, par Jared Richardson & William Gwaltney Jr

Note : 4 ; Dans la continuité des « pragmatic programmers », mais en manque d’originalité.

Qu’est-ce qui fait que certaines équipes s’enlisent, tandis que d’autres parviennent à délivrer ? Cette question est le point récurent des méthodes agiles, c’est le fer de lance de cet ouvrage qui n’a donc pas grand-chose d’original à cet égard. Le texte reprend les bonnes pratiques du « pragmatic programmers », en les unissant dans un processus agile découpé en 3 sous-ensembles (formant autant de chapitres du livre :

Techniques ; Cette partie regroupe 5 pratiques : Technical Lead (en fait le chef de projet), The List (la « feature list » de Scrum), Daily Meeting (le daily meeting d’XP), Code Reviews et Code Change Notifier. Il y a peu d’originalité dans ces pratiques communes à la plupart des méthodes agiles. Toutefois la description du « Technical Lead », à la fois gourou technique et gestionnaire des hommes et des plannings me laisse perplexe, tandis que le manager est vu comme un espèce de VRP…

Infrastructure ; Cette partie regroupe 6 pratiques dont 4 sont liées à l’automatisation : Version Control, Script Builds, Write and Run Tests et Continuous Builds. On remarquera que « continuous build » et « script builds » sont sinon liés, au moins dans la continuité l’un de l’autre. Les deux dernières pratiques sont Track Features et Track Issues, là encore 2 pratiques très liées et intimement liées à « The List », mais vu sous la facette Infrastructure !

La partie Process regroupe 5 pratique liées au développement de l’architecture : Propose System Objects, Propose Interfaces, Connect Interfaces, Add Functions et Refactor Refine Repeat. Le but de cette approche est de définir une architecture par découpage n composants majeurs, puis de définir ces composants par leurs interfaces que l’on connecte ensuite, pour finalement les « étoffer » avec la mécanique. Le réfactoring ajoute la touche finale de raffinement de l’architecture.

Comme je l’ai dit au début, il y a peu d’originalité dans ce livre, même si en soi il constitue un texte valable, il a du mal à sortir du lot. Parmi les particularités, je note toutefois les itérations de longueur variable, mais de contenu fixe. Un point de vue qui, hélas, me laisse également perplexe…

ship-it-pragprog

Référence complète : Ship it ! A practical Guide to Successful Software Projects – Jared R. Richardson & William A. Gwaltney Jr – The Pragmatic Bookshelf 2005 – ISBN : 0-9745140-4-7

Ship It!: A Practical Guide to Successful Software Projects


http://www.goodreads.com/book/add_to_books_widget_frame/0974514047?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Applying Use Cases 2nd edition, par Geri Schneider & Jason P. Winter

Note : 9 ; Un simple raffinement d’un livre déjà excellent, mais qui va dans le bon sens.

J’ai quelques références sur les Use Cases dans ma bibliographie. Ce texte-ci est l’un de mes préférés, sinon mon préféré. Historiquement, à mon échelle, c’est par la note de lecture de la 1ère édition de ce livre que j’ai commencé ma compilation bibliographique il y a maintenant 14 ans.

C’est un ouvrage succinct (environ 170 pages hors annexes), exclusivement destiné aux uses cases, à leur utilisation, leur développements (use case scénarios, diagrammes d’activité, liens vers la modélisation), leur documentation. Le propos est très clair, très direct et bien illustré à l’aide d’un exemple développé au long du livre. La taille réduite du livre fait partie de ses qualités, la substance utile étant très importante. 

Pour cette seconde édition, je m’attendais à d’avantage d’évolutions. En fait, les auteurs ont simplement repris leur matériel de base, en le réorganisant et en mettant à jour certains concepts (relations “includes” et héritage, ainsi que cas d’utilisation subordonnés).  La partie la plus faible de l’édition précédente (documentation des cas d’utilisation) a désormais atteint la qualité des autres chapitres et certains nouveaux thèmes ont été abordés comme les Use Case “CRUD” et les exigences complémentaires. La lourde description de l’étude de cas qui encombrait un peu l’ouvrage a été rejeté en annexe ou elle figure désormais de façon plus complète. Finalement, les auteurs ont réussi le tour de force de remettre à jour cet ouvrage sans nous pénaliser de l’augmentation de volume qui en est le corollaire. Toujours excellent, donc.

Un livre que je conseille très fortement, sans arrières pensés.

applying-usecases-2

Référence complète : Applying Use Cases, second edition, a practical guide – Geri Schneider & Jason P. Winter – Addison Wesley / O.T. series 2001 – ISBN: 0-201-70853-1

Nb: La première édition de cet ouvrage était mon “book of the year” 1998

Applying Use Cases: A Practical Guide


http://www.goodreads.com/book/add_to_books_widget_frame/0201708531?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Crossing the Chasm, par Geoffrey A. Moore

Note : 5 ; Un grand classique du marketing des produits High tech.

Geoffrey Moore est célèbre pour sa fameuse courbe d’adoption des produits High Tech, et c’est bien de cela qu’il est question ici : de l’adoption des produits. Ou plutôt, pour être exact, de la transition séparant les visionnaires et innovateurs des pragmatiques (et des frileux) constituant la « early majority ».

Cet ouvrage est un livre de marketing, il n’y a pas de doutes à avoir là-dessus, aussi les sujets abordés peuvent être troublants parfois pour des techniciens. Mais c’est aussi l’intérêt de ce type de livres : aborder un sujet qui nous est familier avec un regard complètement différent de ce à quoi nous sommes habitués.

Ce grand classique se focalise finalement sur un sujet précis : comment franchir le fossé qui sépare les innovateurs des pragmatiques. Tout d’abord le texte identifie précisément pourquoi ce fossé existe et en quoi il est difficile à franchir car l’approche envers les innovateurs n’est en rien une aide à conquérir les pragmatiques, c’est en fait même souvent l’inverse. La première partie du livre est entièrement consacrée à cet éclairage.

En seconde partie, Geoffrey More nous propose une tactique de conquête de cette autre rive de la courbe : cibler une niche très précise pour y prendre pied, prendre une position dominante sur cette niche étroite en proposant un « produit complet » adapté à la problématique métier, et non simplement un « bel outil » comme l’apprécie les innovateurs. Les chapitres 3 et 4 traitent de cet aspect.

Les derniers chapitres évoquent la façon de vendre ce produit aux pragmatiques et les choix à faire par rapport à la dualité de marché innovateurs / pragmatiques. Quels canaux de vente privilégier, quel profil de force commerciale rechercher.

En ce qui me concerne, deux choses m’ont rendu la lecture un peu difficile : le peu de structure que l’auteur apporte à son propos : Geoffrey Moore adopte un style assez littéraire, fonctionnant plus par association d’idée que par structuration de la pensée. Cela fonctionne certainement assez bien pour des lecteurs baignant déjà bien dans le sujet et qui y possèdent des repères. En revanche, pour les nouveaux venus comme moi, c’est bien plus dur ! Un autre point également, à mettre en perspective avec les livres d’informatique en Anglais que j’ai l’habitude de lire : la variété du vocabulaire. Cela a parfois ralentit ma lecture. Heureusement que le Kindle dispose d’un dictionnaire intégré !

En bref, je n’ai certainement pas perdu mon temps. Les petites difficultés d’immersion dans le texte ont certainement un peu réduit mon plaisir, mais je dois admettre que l’auteur m’a fait découvrir tout un nouveau pan de connaissances relatives à un monde qui est mon quotidien.

CrossingTheChasm

Référence complète : Crossing the Chasm – Geoffrey A. Moore – HaperCollins Publishers 2001 – ISBN : 0-06-008718-8 (Kindle édition)

Crossing the Chasm: Marketing and Selling Technology Project


http://www.goodreads.com/book/add_to_books_widget_frame/0060087188?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Dynamics of Software Development, par Jim & Michele McCarthy & Michele McCarthy

Note : 4 ; Difficile à lire…

Cet ouvrage (plutôt succinct, moins de 200 pages) a été originellement écrit en 1995. L’auteur fut chef de produit sur Visual C++ 1.0, produit que j’ai personnellement trouvé fort peu convaincant, mais il est vrai moins « has been » que son prédécesseur MSC 7.0 ! Le texte est donc assez ancien, datant d’une époque de croissance des applications Windows, et il ignore donc le nouveau paysage créé par l’Internet (dont le texte ne parle pas du tout). Curieusement, dans cette mise à jour, la prose originale n’a pas été touchée, hormis parfois une petite note.

Le livre est structuré en 2 parties, plus une « troisième partie » sous une forme de vidéo de l’auteur. La première partie compte 154 pages divisés en 5 chapitres (de tailles très inégales) plus une annexe, eux-mêmes structurés en 54 items. Ces chapitres correspondent aux phases de développement, non pas calquées sur les classiques et fort peu réalistes « recueil des besoins, analyse, conception, etc… », mais plutôt sur une analogie du jeu d’échec :

• Opening moves : on parle ici du lancement du projet, de son organisation et de ses objectifs.

• The middle game : il représente le « ventre mou » du projet, la partie la plus longue durant laquelle le projet est sur les rails, mais où les features doivent être construites.

• Ship mode : Qu’est-il nécessaire de faire pour livrer le produit, une fois le développement complété ? Ce chapitre traite des activités de fin du projet.

• The launch : Comment gérer une arrivée sur le marché, comment créer un évènement de lancement ?

J’ai trouvé le texte intéressant par endroit, certaines des idées sont franchement précurseur des principes agiles (je pense entre autre aux « feature teams », mais l’aspect historique est généralement de peu d’intérêt pour le lecteur. Le problème le plus ardu est celui de l’anglais, trop recherché et surtout souvent trop imagé qui en diminue l’impact pour le lecteur français. Que penser de « don’t flip the bozo bit », par exemple ?

Bref, malgré sa réputation, je ne saurais conseiller cet ouvrage, pas assez (ou plus assez) original par lui-même et trop difficile à lire, nonobstant son petit volume.

The Dynamics of Software Development

Référence complète : Dynamics of Software Development – Jim McCarthy & Michele McCarthy – Microsoft press 2006 – ISBN : 0-7356-2319-8 ; EAN : 978-0-735-62319-4

Dynamics of Software Development


http://www.goodreads.com/book/add_to_books_widget_frame/0735623198?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on