3 ms·

My impression is that language innovation in lisp dialects is largely stagnant at present. Common lisp is flexible enough that it's reasonable for projects to

My impression is that language innovation in lisp dialects is largely stagnant at present. Common lisp is flexible enough that it's reasonable for projects to stay within the immutable standard, so only library progress happens. Scheme has given up on the minimal side to the design and become over-obsessed with complicated macros and static compilation. I suppose that's change, if not progress. Clojure I can't say much about. I like the hashed trie and do not consider the JVM connection a feature. Maybe that is still changing over time. Racket is still doing its thing, but the current push (Rhombus) seems to mostly be about removing S expressions. Kernel is a different lisp. Tragically we lost the author too young. Kernel deletes most of the limitations and cruft of _scheme_. It would benefit from a sbcl-level of development effort which doesn't seem to be happening. I'm interested anything else strange from the lisp world if people have references. Innovating in the C derivatives continues at pace of course.

KingMob 3y ago
Clojure innovation seems to have largely slowed down, at least from the language maintainers. The last few years have seen lots of little bug fixes, expanding the CLI tool, and better interop with later versions of Java, but nothing major.
pfdietz 3y ago
There is language innovation in Common Lisp, but it's either things that need to be in the standard (example: package local nicknames) or in improved implementation of things in the standard. The latter one I point to often is the problem of efficiently compiling a dynamic language, where (for example) the offsets of slots in objects can be changed at run time, or (another example) where the set of methods for a generic function can change at run time. See Robert Strandh's paper in https://european-lisp-symposium.org/static/proceedings/2021.pdf https://european-lisp-symposium.org/static/proceedings/2021.... (page 72)
- JonChesterfield 3y ago
  Great paper, thank you for the reference!
_19qg 3y ago
There are also innovations in implementations. A recent one was the development of CLASP, a Common Lisp implementation with deep C++ / LLVM integration. https://clasp-developers.github.io https://clasp-developers.github.io "Clasp is a new Common Lisp implementation that seamlessly interoperates with C++ libraries and programs using LLVM for compilation to native code. This allows Clasp to take advantage of a vast array of preexisting libraries and programs, such as out of the scientific computing ecosystem. Embedding them in a Common Lisp environment allows you to make use of rapid prototyping, incremental development, and other capabilities that make it a powerful language."
- JonChesterfield 3y ago
  That description sounds great but the docs are less compelling. The integration is you can write a C++ file that exposes individual functions to lisp, https://clasp-developers.github.io/clbind-doc.html https://clasp-developers.github.io/clbind-doc.html. There doesn't seem to be any way to feed C++ headers into clasp and get out template instantiations accessible to lisp. It looks like SWIG or pybind but you write the shims yourself, and it's function pointer based so templates are wrapped one instantiation at a time. Garbage collection in the docs is a one paragraph stub which suggests you're on your own for lifetime management across the languages. Cool thing to exist. Seamless interoperation is either overselling it or the docs are out of date.
  - _19qg 3y ago
    There is a bit more to it. It allows one to create mixed C++ / Lisp projects with memory management, CLOS methods for C++ classes, CLOS subclass of C++ classes, Lisp and C++ gets compiled to LLVM-IR, debug source output mixing compiled C++ and Lisp frames, ...
hajile 3y ago
The only innovations in the C languages are in making it more like Lisp or working around the deficiencies of a syntax with no macros by adding more syntax on top.
gilch 3y ago
> I'm interested anything else strange from the lisp world if people have references. Hissp just released version 0.4.0. It compiles Python tuples to Python expressions and has multiple readers with different characteristics, not all of which are based on S-expressions. https://github.com/gilch/hissp/discussions/182 https://github.com/gilch/hissp/discussions/182

KingMob 3y ago

Clojure innovation seems to have largely slowed down, at least from the language maintainers. The last few years have seen lots of little bug fixes, expanding the CLI tool, and better interop with later versions of Java, but nothing major.

pfdietz 3y ago

There is language innovation in Common Lisp, but it's either things that need to be in the standard (example: package local nicknames) or in improved implementation of things in the standard. The latter one I point to often is the problem of efficiently compiling a dynamic language, where (for example) the offsets of slots in objects can be changed at run time, or (another example) where the set of methods for a generic function can change at run time. See Robert Strandh's paper in https://european-lisp-symposium.org/static/proceedings/2021.pdf https://european-lisp-symposium.org/static/proceedings/2021.... (page 72)

JonChesterfield 3y ago
Great paper, thank you for the reference!

_19qg 3y ago

There are also innovations in implementations. A recent one was the development of CLASP, a Common Lisp implementation with deep C++ / LLVM integration. https://clasp-developers.github.io https://clasp-developers.github.io "Clasp is a new Common Lisp implementation that seamlessly interoperates with C++ libraries and programs using LLVM for compilation to native code. This allows Clasp to take advantage of a vast array of preexisting libraries and programs, such as out of the scientific computing ecosystem. Embedding them in a Common Lisp environment allows you to make use of rapid prototyping, incremental development, and other capabilities that make it a powerful language."

JonChesterfield 3y ago
That description sounds great but the docs are less compelling. The integration is you can write a C++ file that exposes individual functions to lisp, https://clasp-developers.github.io/clbind-doc.html https://clasp-developers.github.io/clbind-doc.html. There doesn't seem to be any way to feed C++ headers into clasp and get out template instantiations accessible to lisp. It looks like SWIG or pybind but you write the shims yourself, and it's function pointer based so templates are wrapped one instantiation at a time. Garbage collection in the docs is a one paragraph stub which suggests you're on your own for lifetime management across the languages. Cool thing to exist. Seamless interoperation is either overselling it or the docs are out of date.
- _19qg 3y ago
  There is a bit more to it. It allows one to create mixed C++ / Lisp projects with memory management, CLOS methods for C++ classes, CLOS subclass of C++ classes, Lisp and C++ gets compiled to LLVM-IR, debug source output mixing compiled C++ and Lisp frames, ...

hajile 3y ago

The only innovations in the C languages are in making it more like Lisp or working around the deficiencies of a syntax with no macros by adding more syntax on top.

gilch 3y ago

> I'm interested anything else strange from the lisp world if people have references. Hissp just released version 0.4.0. It compiles Python tuples to Python expressions and has multiple readers with different characteristics, not all of which are based on S-expressions. https://github.com/gilch/hissp/discussions/182 https://github.com/gilch/hissp/discussions/182