Readit NewsThe Gambit Scheme REPL that comes with a tutorial, supports threads in the browser and has a JS FFI: https://try.gambitscheme.org
Gambit in emacs in the browser: https://feeley.github.io/gambit-in-emacs-in-the-browser/
I don't know if you've been tracking it lately, but there was a big overhaul last year [1]. The version in your second link doesn't seem to work in current Firefox. If you'd like to update and need any help, please feel free to get in touch. (also, there's still some of your code in Ymacs :) although I kinda broke filename completion...)
But JSCL is much faster on the fib example, that's why I thought it should be generally faster. After all, it compiles to JS.
SL-USER> (time (loop for i below (expt 10 8) count t))
Evaluation time: 19376ms
100000000
SL-USER> (time (loop for i below 1000000 count t))
Evaluation time: 272ms
1000000
SL-USER> (defun fib (n) (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2)))))
#'FIB
SL-USER> (time (fib 32))
Evaluation time: 1601ms
2178309
I used to think it's quite slow, but somehow it's much faster than any other posted here. The only Lisp in browser I know to beat SLip (by a large margin) is JSCL, which compiles to JS.
One day, a Gnome update breaks all plugins, in one case making login in X impossible unless you manually deactivate stuff using the shell. The next time, a kernel update makes sound stop working after waking up from standby. It's mostly small regressions, and they usually get fixed a week later, but something temporarily stops working at least once every 2 months.
However, Arch also makes it much, much easier to run recent versions of, basically everything. You never have to fiddle around with 3rd-party package repos, you just install stuff and it works. It's how package managers are supposed to work, but not the experience I've ever had with Debian and Ubuntu. Of course, the fact that Pacman is fantastically fast compared to apt doesn't hurt either.
I love Arch. In aggregate, I think it prevents more headaches than it causes. But you have to be prepared for some unexpected problems and fiddling around.
After a while, though, I switched to KDE and life's good again.
[1] https://github.com/mishoo/boring-gnome-mishoo.github.com
This can be done in a number of other common languages today such as Java (JVM languages) and C# (probably all .NET languages). Most IDEs I've seen for those platforms support it.
Substantial enough changes to the code can require an application restart, but most changes you might make like changing the implementation of a function, adding new functions to a class, etc., will not. Hot Code Replacement (HCR) has been supported since Java 1.4: https://wiki.eclipse.org/FAQ_What_is_hot_code_replace%3F
Fully dynamic languages like Lisp and Smalltalk permit a greater degree of this than statically typed languages do, however, since they don't have types and a type system to wrangle with. When I've used it, hot code replacement supported most of the changes that conceptually make sense to support.
Doing an `npm run dev` type of command in a reasonably set up JS project is very much this staged execution model the author talks about. Everything gets cached, on disk and in memory, only changes are recompiled, and reloads are fast, partial, and often hot-swapped. It's quite close to the maximum level of "liveness" I can imagine.
It's kind of amazing how JS took over older and more established languages in this sense - and we're still not content (judging by how popular it is to complain about webpack). This is great.
Common Lisp had true liveness for decades; it's almost mandated by the standard, it's designed in such a way that you can actually recompile a function, or even redefine objects, adding or removing properties or methods, at fucking runtime without restarting the application. Objects already instantiated will remain so and will be updated to reflect the change. You don't restart. That's the true "liveness", but seriously you don't get it until you try it, and once you get it you become depressed because you realize it doesn't really exist in any mainstream language.
JavaScript is some decades behind this dream, even with stuff like Webpack.