Renato Athaydes

Here's the follow-up with an optimized CL version: https://renato.athaydes.com/posts/revenge_of_lisp-part-2.html See the conclusion: - the CL version is the fastest of ALL… in certain conditions ;)

The classic, now quiet dated citation, is "An empirical comparison of C, C++, Java, Perl, Python, Rexx, and Tcl" by Lutz Prechelt. Recent-ish commentary (July 2021) about it at https://renato.athaydes.com/posts/revisiting-prechelt-paper-comparing-… , HN commentary at https://news.ycombinator.com/item?id=28108806 . Google Scholar gives about 476 paper which cite Prechelt's work. I have not followed other work in that field.

A recent blog post discussing some other ways to run Java in the browser: https://renato.athaydes.com/posts/comparing-jvm-alternatives-to-js.htm… I currently use TeaVM and it's excellent, but I'll give J2CL a try.

I've found this helpful review on Unison albeit the article is from 2023 [1]. [1] A look at Unison: a revolutionary programming language: https://renato.athaydes.com/posts/unison-revolution.html

I think it was this blog: https://renato.athaydes.com/all-posts They also tested common lisp!

The new release of TeaVM (0.11.0) now supports WebAssembly GC. This increases performance while further decoupling TeaVM apps from ECMAScript. TeaVM ( https://teavm.org/ ) is an Apache-licensed project, free for use in commercial projects. It is mature and used widely, including in frameworks like Flavour ( https://frequal.com/Flavour/book.html ) and more projects listed here: https://www.frequal.com/TeaVM/TeaVmBasedSites.html TeaVM compiles Java code to run in the browser, efficiently and quickly. It features short build times, small downloadable files, and a batteries-included toolset (including minification, tree-shaking, and packaging). Previous releases have conquered all similar open-source tools (that support threading) in independent testing: https://renato.athaydes.com/posts/comparing-jvm-alternatives-to-js.htm…

The next blog post goes into more detail regarding possible optimizations. https://renato.athaydes.com/posts/how-to-write-slow-rust-code.html The JVM startup time is discussed, and it mentions that a pre-compiled version using Graal might make for an interesting comparison. It wasn't done, because as mentioned in the blog post, things were getting out of hand with all the extra testing.

If that's your main downside, that's pretty good, since clunkiness is in many ways fixable. Personally with standard CL I like to use property lists with keywords, so a "map literal" is just (list :a 3 :b 'other). It's fine when the map is small. The getter is just getf, setting is the usual setf around the getter. There's a cute way to loop by #'cddr for a key-and-value loop, though Alexandria (a very common utility library) has some useful utils for looping/removing/converting plists as well. If typing out "(list ...)" is annoying, it's a few lines of code to let you type {:a 3 :b 4} instead, like Clojure. And the result of that can be a plist, or a hash table, or again like Clojure one of the handful of immutable map structures available. You can also easily make the native hash tables print themselves out with the curly bracket syntax. (On the speed front, you might be amused by https://renato.athaydes.com/posts/how-to-write-slow-rust-code.html But separately, when you want to speed up Lisp (with SBCL) even more than default, it's rather fun to be able to run disassemble on your function and see what it's doing at the assembly level, and turn up optimization hints and have the compiler start telling you (even on the individual function level) about where it has to use e.g. generic addition instead of a faster assembly instruction because it can't prove type info and you'll have to tell it/fix your code. It can tell you about dead code it removed. You can define…

I'm also very curious for hear from expert lispers. I've tried to find the sweat spot where lisp would fit better than what I already know: shell for glue and file ops, R for data munging and vis, python to not reinvent things, perl/core-utils for one liners. But before I can find the niche, I get turned off by the amount of ceremony -- or maybe just how different the state and edit/evaluate loop is. I'm holding onto some things that make common lisp look exciting and useful (static typing[0], APL DSL[1], speed [2,3,4]) and really want to get familiar with structural editing [5] [0] https://github.com/phantomics/april [1] https://github.com/coalton-lang/coalton/ [2] https://renato.athaydes.com/posts/revisiting-prechelt-paper-comparing-… [3] https://github.com/fukamachi/woo/blob/master/benchmark.md [4] https://tapoueh.org/blog/2014/05/why-is-pgloader-so-much-faster/ [5] https://github.com/drym-org/symex.el