Maintenant que par la vertu d'une précédente prophétie auto-réalisatrice les SGBDR sont pratiquement morts, il est temps de passer à l'étape suivante, le sacro-saint tableur, dont la principale incarnation se trouve être Microsoft Excel. J'étais confiant, je n'étais pas à mon coup d'essai dans l'extermination de produits emblématiques. Après tout j'avais déjà consacré 2 ans à réinventer le traitement de texte avec "Novelang"
, puis 1 an à "mettre fin au règne des SGBDR"
. Donc l'extermination d'Excel me semblait tout à fait atteignable, avec cependant la contrainte de ne pas y passer plus de deux jours. Je suis fier d'annoncer que c'est chose faite.
== Excel c'est quoi ?
Tout d'abord il convient de rappeler ce qu'est un tableur.
C'est un outil de calcul qui donne accès interactivement à une matrice dont les cellules peuvent être des valeurs, ou des formules référençant d'autres cellules. Dans les années 80 c'est devenu l'objet d'une adoration mystique par des gens qui croyaient par ce biais comprendre quelque chose à l'informatique, alors qu'en général ils se contentaient de faire de la mise en page et d'administrer des bases de données avec un outil qui n'est évidemment pas fait pour.
Le tableur, c'est le triomphe d'un discours ambivalent qui glorifie les vertus révolutionnaires de l'informatique tout en prétendant que l'histoire s'arrête à un seul outil, qui le plus souvent se retrouve mal compris et mal utilisé. C'est vrai qu'Excel, c'est bien pour écrire des programmes en faisant un gros doigt à tous ces idiots d'informaticiens qui ont besoin de cinq années d'études post-bac pour apprendre faire une addition. (Bon d'accord les SGBDR ne les ont pas aidés mais je me suis déjà exprimé là-dessus.)
Dans ce contexte, le tableur n'est là que pour être tué.
Il y a eu des tentatives de réinventer cette bête-là. J'aime particulièrement `Spreadsheet 2000`, décrit à la p. 17 de "An Extended Spreadsheet Paradigm for Data Visualisation Systems, and its Implementation"
. `Spreadsheet 2000` définit des sources de données tabulaires et des opérateurs de transformation qui produisent d'autres sources. Au moins c'est compréhensible et élégant. Mais `Spreadsheet 2000` est mort depuis 20 ans et personne n'a l'air pressé de lui redonner vie. Tant pis ou tant mieux.
== Le problème
Il y a peu j'ai du mettre en place une comptabilité domestique. J'étais dans le cas typique du truc simple qui devrait se résoudre avec une feuille de calcul, éventuellement avec une base de donnée bureautique. Je voulais un logiciel libre comme OpenOffice. Je voulais un maximum de contrôles lors de la saisie. Après il y a juste quelques rapprochements à faire entre diverses écritures pour sortir quelques totaux. Donc pas la mort, apparemment.
Je découvrais la comptabilité donc j'ai bricolé un peu. J'ai compris que le plus important c'était de bien dissocier la date d'un mouvement de l'exercice auquel il s'appliquait. J'ai vu que tout pouvait se modéliser sous forme d'événements de type preuve de vente, facture ou réglement.
Mais plus j'essayais de faire rentrer ça dans un outil bureautique moins ça marchait.
== La solution
Je me suis dit "Bande d'enfoirés ça serait plus simple en Kotlin. Surtout si les lignes d'événements je les déclare directement comme constantes dans le code !"
Les constantes dans le code ça limite la séparation donées-traitement et on n'a pas besoin d'écrire un parseur ou une couche d'accès aux données.
Après il faut bien utiliser les possibilités du langage. J'ai mis les dates des mouvements et des exercices, ainsi que les imputations comptables dans des ``enum`` de façon à limiter les erreurs de saisie. J'ai créé des ``data class`` pour représenter les différents événements. J'ai écrit des fonctions pour faire les rapprochements et pour imprimer des rapports en mode caractère.
Une ``enum`` Java possède au plus 65535 éléments, donc si on y met une série de dates elle s'étendent au moins sur 179 ans. Les événements sont dans une liste, qui accepte jusqu'à 2 milliards d'éléments. Donc j'ai la paix pour quelques temps.
Si j'ai besoin de restructurer j'ai les outils de refactorisation d'IntelliJ IDEA, ainsi que l'éditeur avec des regex bien pratiques, ainsi que l'édition multicurseur (géniale). Si je veux un rapport particulier, je me le code en Kotlin qui manipule très bien les collections. Tout est testable unitairement. Le code est versionné avec git.
Voici à quoi ressemble une ligne d'événement :
<<<
Reglement( D_2018_01_31, E_2018_02, FRAIS, 60.39f, "Leclerc (essence)" ),
>>>
Ça veut dire que le 1^er mars on effectue un réglement de ``60,39 €`` pour des frais durant l'exercice de février. Et une fois que le programme qui pond tous les rapports compile et s'exécute sans erreur, on est sûr que toutes les validations possibles ont eu lieu.
En plus il est facile d'intégrer des fonctionnalités qui seraient horribles à développer en VBA, comme l'import de fichiers OFX pour pointer les mouvements dans un compte bancaire.
== Utilisabilité
Il est clair que ma solution uniquement basée sur un langage de programmation ne peut pas être mise entre les mains de gens "normaux".
Ah, vraiment ?
J'ai mis en place une solution analogue pour une plateforme de négociation de produits dérivés. L'expert fonctionnel élabore une liste de produits prédéfinis. Pour gagner du temps on a décidé de se passer de procédés biscornus comme l'import de feuilles Excel et de lui faire taper directement du code Java. Il y a IntelliJ IDEA sur la machine du gars, il sait faire un pull et un commit-and-push dans son repo perso sur GitHub. Il sait sur quel bouton appuyer pour tout construire et lancer la démo.
Comme la syntaxe est très simple et que l'éditeur montre les erreurs, on n'a jamais eu de souci de ce côté-là. Et s'il y a besoin de refactoriser c'est le programmeur qui le fait, après on se synchronise avec git.
On pourrait penser que le tableur est plus facile d'emploi du fait de la saisie interactive. Par exemple, il détecte certains formats invalides. Mais c'est très limité. Ce qu'on veut c'est un message d'erreur qui dise que la donnée X ne colle pas avec la donnée Y et pourquoi, et si c'est un peu compliqué ça ramène fatalement au traitement par lot. Il faut noter qu'en amont de ça un éditeur pleine page avec de la coloration syntaxique fournit déjà un retour d'erreur satisfaisant.
Donc Excel ne nous manque pas.
== Conclusion
IntelliJ IDEA est capable d'indexer des millions de symboles pour fournir une aide à la saisie. Autant que je sache il supporte la compilation différentielle. Comme on peut tester son code unitairement il y a moyen de vérifier que les rapports fonctionnent sans charger toutes les données. Si on a besoin de rapports sophistiqués, Kotlin est le meilleur langage généraliste du moment, réunissant tous les avantages de Java, Python et JavaScript. Et si on a besoin de jolis rapports, la bibliothèque "``kotlinx.html``"
fournit un langage de patronnage hors-pair pour du XML ou du HTML.
Depuis qu'elles existent, les suites bureautiques naviguent péniblement parmi des exigences contradictoires, la principale étant de faire croire à leurs utilisateurs qu'ils n'étaient pas des développeurs. Pendant ce temps là, les environnement de développement et les langages ont évolué, la mémoire disponible a formidablement augmenté. Pour automatiser des traitements on s'aperçoit que l'important c'est la restructuration, le versionnage et la testabilité, ce qui met hors-jeu les solutions de type base de donnée bureautique ou tableur.