stephanet

Ou la guerre des LISP.

J’ai eu une discussion dernièrement avec Jean Philippe Paradis, un partisan activiste de Common Lisp qui veut remettre ce langage dans le TOP 5 pour 2040.

Une posture qui m’a fait sourire, non que je n’aime pas en CL, c’est un excellent langage que j’utilise souvent et que j’apprécie beaucoup. Mais je suis bien conscient que c’est plus par nostalgie que pour les qualités techniques d’un langage dont la conception rigide commence à dater un peu face à l’évolution des langages modernes tels que Java, GO, Clojure.

Common Lisp est un language basé sur Lisp et qui n’a fait qu’accumuler couches après couches des fonctionnalités afin de garder le niveau par rapport `a ses concurrents les plus récents. Ce qui le rend inutilement verbeux et peu consistent.

Petit exemple tout bête, déclarer et renseigner une table de hachage en CL:

(def *h* (make-hash-table :test 'equal))
(setf (gethash "key" *h*) "value")

Ce qu’on déclarera beaucoup plus simplement avec Clojure:

(def h {'key' 'value'})

Bien sur, puisque les tables de hachage sont parties intégrante de Clojure, alors qu’ils sont une pièce rapportée à CL.

Il en va de même avec le multi-threading. Tous les compilateurs Common Lisp sont multi-threadés par défaut, mais comme cette fonctionnalité ne fait pas partie de CL à l’origine, la gestion des locks se fait par des mécanismes de lock qu’il faut gérer. Si bien que passer un code de mono-threadé à multi-threadé ne peut pas se faire de façon transparente à cause des accès concurrents.

Clojure est immutable par défaut et la modification de variables doit passer par des mécanismes déjà intégrés au langage tels que les atoms, les ref et les agents. Les ref intègrent même un mécanisme de transactions similaires aux bases de données ou un ensemble de modifications peuvent exécutées à l’intérieur d’une transaction avec l’assurance que si l’une d’entres elles échoue, alors aucune ne sera exécutée (commit ou rollback). Le tout est absolument thread-safe.

Et tout est à l’avenant parce que Clojure intègre nativement les tableaux, le multi-threading, les accès concurrents, les transactions en mémoire. Comme il a été conçu par une seule personne (ou une petite équipe), il est consistent, les ordres des arguments sont toujours les mêmes, il utilise les mêmes fonctions sur des structures de données différentes sans ré-inventer la roue à chaque fois.

Bref, si nous avons une chance de voir un Lisp se retrouver dans le Top 5 des langages pour 2040, Clojure a une bien meilleure chance d’y arriver que Common Lisp.