Pourquoi la communauté Lisp est-elle si fragmentée?

Pour commencer, non seulement il existe deux dialectes principaux de la langue (Common Lisp et Scheme), mais chacun des dialectes a de nombreuses implémentations individuelles. Par exemple, programme de poulet, Bigloo, etc … chacun avec de légères différences.

D’un sharepoint vue moderne, c’est étrange, car les langages actuels ont tendance à avoir des implémentations / spécifications définitives. Pensez à Java, C #, Python, Ruby, etc., où chacun possède un site unique et définitif auquel vous pouvez accéder pour les documents API, les téléchargements, etc. Bien sûr, Lisp est antérieur à toutes ces langues. Mais encore une fois, même C / C ++ sont normalisés (plus ou moins).

La fragmentation de cette communauté est-elle due à l’âge de Lisp? Ou peut-être que différentes implémentations / dialectes sont destinés à résoudre différents problèmes? Je comprends qu’il y a de bonnes raisons pour lesquelles Lisp ne sera jamais aussi unie que les langages qui se sont développés autour d’une seule implémentation définitive, mais y a-t-il une bonne raison pour laquelle la communauté Lisp ne devrait pas aller dans cette direction?

La communauté Lisp est fragmentée, mais tout le rest l’est aussi.

  • Pourquoi y a-t-il tant de dissortingbutions Linux?

  • Pourquoi y a-t-il tant de variantes BSD? OpenBSD, NetBSD, FreeBSD, même Mac OS X.

  • Pourquoi y a-t-il autant de langages de script? Ruby, Python, Rebol, TCL, PHP et d’innombrables autres.

  • Pourquoi y a-t-il tant de shells Unix? sh, csh, bash, ksh, …?

  • Pourquoi y a-t-il tant d’implémentations de Logo (> 100), Basic (> 100), C (innombrables), …

  • Pourquoi y a-t-il tant de variantes de Ruby? Ruby MRI, JRuby, YARV, MacRuby, HotRuby?

  • Python peut avoir un site principal, mais il existe plusieurs implémentations légèrement différentes: CPython, IronPython, Jython, Python pour S60, PyPy, Unladen Swallow, CL-Python, …

  • Pourquoi y a-t-il C (Clang, GCC, MSVC, Turbo C, Watcom C, …), C ++, C #, Cilk, Objective-C, D, BCPL, …?

Il suffit de laisser certains d’entre eux en avoir cinquante et de voir combien de dialectes et d’implémentations il a à ce moment-là.

Je suppose que Lisp est diversifiée, car chaque langue est diverse ou diversifiée. Certains commencent par une seule implémentation (McCarthy’s Lisp) et après cinquante ans, vous avez un zoo. Common Lisp a même démarré avec de multiples implémentations (pour différents types de machines, systèmes d’exploitation, avec différentes technologies de compilation, …).

Aujourd’hui, Lisp est une famille de langues , pas une seule langue. Il n’ya même pas de consensus sur les langues qui appartiennent à cette famille ou non. Il peut y avoir des critères à vérifier (expressions-s, fonctions, listes, etc.), mais tous les dialectes Lisp ne supportent pas tous ces critères. Les concepteurs de langage ont expérimenté différentes fonctionnalités et nous avons obtenu de nombreux langages de type Lisp.

Si vous regardez Common Lisp, il existe environ trois ou quatre fournisseurs commerciaux actifs différents. Essayez de les amener derrière une offre! Ne fonctionnera pas. Ensuite, vous avez un tas d’implémentations open source actives avec des objectives différents: l’une comstack en C, une autre est écrite en C, on essaie d’avoir un compilateur à optimisation rapide, on essaie d’avoir un terrain intermédiaire avec une compilation native. JVM … et ainsi de suite. Essayez de dire aux responsables de supprimer leurs implémentations!

Scheme compte environ 100 implémentations. Beaucoup sont morts ou pour la plupart morts. Au moins dix à vingt sont actifs. Certains sont des projets de loisir. Certains sont des projets universitaires, certains sont des projets d’entresockets. Les utilisateurs ont des besoins divers . Il faut un GC en temps réel pour un jeu, un autre doit être intégré dans C, il suffit de construire des barebones à des fins éducatives, etc. Comment dire aux développeurs de ne pas pirater leur implémentation.

Ensuite, il y en a qui n’aiment pas Commmon Lisp (trop grand, trop vieux, pas assez fonctionnel, pas assez orienté object, trop rapide, pas assez rapide, …). Certains n’aiment pas le Scheme (trop académique, trop petit, pas évolutif, trop fonctionnel, pas assez fonctionnel, pas de modules, les mauvais modules, pas les bonnes macros, …).

Ensuite, quelqu’un a besoin d’un Lisp combiné à Objective-C, puis vous obtenez Nu. Quelqu’un pirate du Lisp pour .net. Ensuite, vous obtenez des Lisp avec des access simultanés et de nouvelles idées, puis vous avez Clojure.

C’est l’ évolution du langage au travail . C’est comme l’explosion cambrienne (quand beaucoup de nouveaux animaux sont apparus). Certains mourront, d’autres vivront, d’autres apparaîtront. À un certain moment, des dialectes apparaissent, qui reprennent l’état de l’art (Schéma pour tout avec une functional programming en Lisp dans les années 70/80 et Common Lisp pour tout ce qui ressemble à MacLisp dans les années 80). à savoir Standard Lisp, InterLisp et autres).

Common Lisp est l’alligator des dialectes Lisp. C’est un design très ancien (cent millions d’années) avec peu de changements, un peu effrayant, et de temps en temps il mange des jeunes …

Si vous voulez en savoir plus, The Evolution of Lisp (et les diapositives correspondantes ) est un très bon début!

Je pense que c’est parce que “Lisp” est une description si large d’une langue. La seule chose commune entre toutes les lisps que je connais est que la plupart des choses sont entre parenthèses, et utilise la notation de fonction de préfixe. Par exemple

(fun (+ 3 4)) 

Cependant, presque tout le rest peut varier entre les implémentations. Scheme et CL sont des langages complètement différents et doivent être considérés comme tels.

Je pense que fragmenter la communauté lisp est comme appeler la communauté “C like” fragmentée. Il a c, c ++, d, java, c #, go, javascript, python et beaucoup d’autres langages que je ne peux pas penser.

En résumé: Lisp est plus une propriété de langage (comme le garbage collection, le typage statique) qu’une implémentation de langage réelle, il est donc tout à fait normal que de nombreux langages aient la même propriété Lisp, comme de nombreux langages disposent d’un nettoyage de mémoire.

Je pense que c’est parce que Lisp est née et conserve l’esprit de la culture des hackers. La culture des hackers consiste à prendre quelque chose et à le rendre «meilleur» selon votre croyance en «mieux».

Ainsi, lorsque vous avez une bande de pirates informatiques et une culture de modification, la fragmentation se produit. Vous obtenez Scheme , Common Lisp , ELISP , Arc . Ce sont tous des langages assez différents, mais ils sont tous “Lisp” en même temps.

Maintenant, pourquoi la communauté est-elle fragmentée? Eh bien, je blâme le temps et la maturité sur cela. La langue a 50 ans! 🙂

Scheme et Common Lisp sont normalisés. SBCL semble être le code source ouvert de facto et de nombreux exemples expliquent comment l’utiliser. C’est rapide et gratuit. ClozureCL a aussi l’air très bien.

PLT Scheme semble être le schéma open source de facto et il existe de nombreux exemples d’utilisation. C’est rapide et gratuit.

Le CL HyperSpec semble aussi bon que le JavaDoc.

En ce qui concerne la fragmentation de la communauté, je pense que cela a peu à voir avec les normes ou les ressources. Je pense que cela a beaucoup plus à voir avec ce qui a été une communauté relativement petite jusqu’à récemment.

Je pense que Clojure a de bonnes chances de devenir The Lisp pour la nouvelle génération de codeurs.

Peut-être mon sharepoint vue est une mise en œuvre très populaire, tout ce qui est nécessaire pour donner l’ illusion d’une communauté cohérente.

LISP n’est pas aussi fragmenté que BASIC.

Il y a tellement de dialectes et de versions de BASIC que j’ai perdu le compte.

Même l’implémentation la plus utilisée (MS VB) est différente entre les versions.

Le fait qu’il existe de nombreuses implémentations de Common LISP devrait être considéré comme une bonne chose. En fait, étant donné qu’il ya à peu près le même nombre d’implémentations gratuites de Common LISP que d’implémentations gratuites de C ++ est remarquable, compte tenu de la popularité relative des langues.

Les implémentations Common LISP gratuites incluent CMU CL, SBCL, OpenMCL / Clozure CL, CLISP, GCL et ECL.

Les implémentations C ++ gratuites incluent G ++ (avec les variantes Cygwin et MinGW32), Digital Mars, Open Watcom, Borland C ++ (inheritance?) Et CINT (interpréteur). Il existe également diverses implémentations STL pour C ++.

En ce qui concerne Scheme et Common LISP, bien qu’anormalement une analogie inexacte, il ya des moments où je considérerais Scheme comme Common LISP ce que C est en C ++, c’est-à-dire que Scheme et C sont petits et élégants (sans doute) plus adapté aux applications plus grandes.

Deux facteurs consortingbutifs possibles:

Les langages Lisp ne sont pas très populaires par rapport à d’autres langages comme C / C ++ / Ruby, etc. – cela seul peut donner l’illusion d’une communauté fragmentée. Il peut y avoir une fragmentation égale dans les autres communautés linguistiques, mais une plus grande communauté aura de plus grands fragments.

Les langages Lisp sont plus faciles à mettre en œuvre que la plupart des autres. J’ai vu beaucoup d’implémentations Lisp “jouets” que les gens ont faites pour le plaisir, beaucoup de “bonnes” implémentations Lisp pour résoudre des tâches spécifiques. Il y a beaucoup plus d’implémentations Lisp qu’il y a, disons, d’interprètes Python (je suis au courant de .. 5, dont la plupart sont généralement interchangeables)

Il y a des projets prometteurs comme Clojure, qui est un nouveau langage, avec un objective clair (concomitance), sans trop de «bagage historique», facile à installer / configurer, qui peut se greffer sur la bibliothèque «écosystème» de Java. bibliothèques et dispose d’une liste de diffusion officielle. Cela vérifie à peu près tous les problèmes que j’ai rencontrés en essayant d’apprendre le Common Lisp il y a quelque temps, et encourage une communauté plus centralisée.

Mon sharepoint vue est que Lisp est un petit langage, donc facile à implémenter (comparé à Java, C #, C, …)

Avoir plusieurs implémentations est bénéfique, car chaque implémentation est optimale dans des endroits uniques. Et les langages grand public modernes n’ont pas une seule implémentation. Pensez à Python: son implémentation principale est CPython, mais grâce à JPython, vous pouvez également exécuter Python sur la JVM. Grâce à Stackless Python, vous pouvez avoir une concurrence massive grâce aux microtreads; etc. De telles implémentations seront englobées à certains égards: JPython s’intègre parfaitement à Java, tandis que CPython ne l’intègre pas. Même chose pour Ruby.

Ce que vous ne voulez pas, c’est avoir de nombreuses implémentations incompatibles avec l’os. C’est le cas avec Scheme, où vous ne pouvez pas partager les bibliothèques entre les implémentations sans réécrire beaucoup de code, car les Schemers ne peuvent pas s’entendre sur la manière d’importer / exporter des bibliothèques. Les librairies Lisp communes, OTOH, en raison de la normalisation dans les domaines centraux, sont plus susceptibles d’être portables, et il existe des possibilités d’écrire de manière conditionnelle du code pour gérer les particularités de chaque implémentation. En fait, vous pouvez dire aujourd’hui que Common Lisp est défini par ses implémentations (pensez à la bibliothèque d’installation du package ASDF), tout comme les langages traditionnels.