4 ms·
Cl-kawa: Scheme on Java on Common Lisp
- zombot 8mo agoI haven't tried it, but the description sounds delightfully perverse. And an LLM (Claude) cannot be embarrassed by perverting Lisp/Scheme with Java.
- pjmlp 8mo agoWhy should it? "We were after the C++ programmers. We managed to drag a lot of them about halfway to Lisp." -- Guy Steele
- anthk 8mo agoRMS itself being a diehard Scheme and Elisp user said that he found Java elegant over C. This was OFC long before Go and when C++ was king in the 90's. On Java itself, when CLOS, a dog-ancient system for Common Lisp it's enough to support the Java class/method/object system by itself tells a lot on how great CL can be, even with SBCL which is the top tier free (as in freedom) interpreter/compiler out there. On performance, well, who knows; remember that PyPy itself back in the day was written in Python itself and it ran things much faster than the vanilla Python interpreter.
- anthk 8mo agoThe Computer Abstractions book/course for Scheme had some kind of VM written in Java where you had to write an assembler in Scheme as the final 'biggie' project.
- brazzy 8mo agoJVM, not Java. And there's Clojure already in that space.
- zombot 8mo agoAgreed, "Java" was an oversimplification. It's actually JVM bytecode. It's still strange in my book to use an object soup runtime for something (Lisp/Scheme) that feels closer to functional languages to me. Clojure is a different case, because when you already are on the JVM anyway, then Clojure is still infinitely better than no Lisp at all. It's not the same as putting the JVM somewhere where it wasn't before and where it's not actually needed.
- atgreen 8mo agoIt's like Dr Ian Malcolm says.. "Your developers were so preoccupied with whether or not they could, they didn't stop to think if they should" - Jurrasic Park (almost)
- brazzy 8mo agoA serious Lisp/Scheme runtime needs a garbage collector. The JVM has probably the most advanced GC implementation around - for that reason alone it doesn't seem particularly strange to me.
- Per_Bothner 8mo agoKawa predates Clojure by a decade. (Kawa work started 1996; Clojure's initial release was 2007.) Also, Clojure isn't really focused on high performance, while that has always been a priority for Kawa, which generates bytecode similar to Java, especially if you include suitable type annotations. (It is likely Clojure have have improved in this respect - they have a lot more people working on it.)
- nxobject 8mo agoThe OpenLDK is very interesting - it looks like it “compiles” to the vintage procedural dialect within CL (eg TAGBODY etc.) I wonder if someone’s ever bypassed the “procedural Lisp” level and just used a CL implementation’s internal assembler interactively, though. (IIRC both SBCL and CCL expose theirs.)
- varjag 8mo agoTAGBODY/GO are broadly used in advanced Lisp macros. If you expand a non-trivial extended LOOP invocation you'd likely see some. If you compile to an implemenation's assembler (even where that possible) you don't really compile into Lisp anymore. And really the Lisp compiler is going to do a better job at generating machine code.
- stassats 8mo agoI did that to write simd routines for sbcl: https://github.com/sbcl/sbcl/blob/master/src/code/arm64-simd.lisp#L819 https://github.com/sbcl/sbcl/blob/master/src/code/arm64-simd... Probably the best way of writing assembly, can evaluate the function immediately, use macros and any other code to emit instructions, even can print register values (instruction-level stepping would be even better, but too much work).
- rhkalth 8mo agoAnd? Do you want a medal for plagiarizing other people's work?
- klez 8mo agoI'll bite. What have they plagiarized?
- anthk 8mo agoOn OpenLDK, if it's able to run something like SweetHome3D at usable speeds I would consider it a success and an interesting exercise.
- atgreen 8mo agoIf you are interested in this, you might also be interested to learn that I also got clojure running on SBCL via OpenLDK. See https://github.com/atgreen/cl-clojure https://github.com/atgreen/cl-clojure. Regarding LLM-usage, the bulk of OpenLDK was written without the use of LLMs. But recently I let Claude loose on the code to fix a few remaining problems blocking kawa. Claude also upleveled the Java support from Java 8 to Java 21. I wrote a couple of blog entries related to this work that might be of interest. One was around how I had to use the MOP to optimize method dispatch in CLOS for clojure: https://atgreen.github.io/repl-yell/posts/clos-mop-dispatch/ https://atgreen.github.io/repl-yell/posts/clos-mop-dispatch/
- atgreen 8mo agoHere's something I wrote about this work: https://atgreen.github.io/repl-yell/posts/cl-kawa/ https://atgreen.github.io/repl-yell/posts/cl-kawa/
- varjag 8mo agoPerhaps someone could port Arc to Kawa! Then the whole contraption could run HN on SBCL in a roundabout way.
- stared 8mo agoI had to check if the creator is Polish, as "ciekawa" means "interesting". But apparently, just a coincidence.
- cloudbonsai 8mo agoCoincidentally, Chi-kawa is a very popular anime character in Japan. https://en.wikipedia.org/wiki/Chiikawa https://en.wikipedia.org/wiki/Chiikawa It's a portmanteau of "Chiisai" (small) and "Kawaii" (cute).
- tmtvl 8mo agoWell, GNU Kawa is named after the Polish word for coffee (going with a play on Java rather than a play on Scheme like Guile and Larceny EDIT: and Gambit went with).
- mark_l_watson 8mo agoGithub user atgreen has a large number of really interesting Common Lisp projects: https://github.com/atgreen https://github.com/atgreen I am a fan.
- shawn_w 8mo agoThe newer ones are mostly vibecoded if that matters to you.
- Per_Bothner 8mo agoWhat a blast from the past! I too remember with pleasure the days working with Anthony Green (and others) at Cygnus. I like to boast that (apart from Java) Kawa Scheme is the oldest compiler-based language implementation still available for the JVM.