[nobleach]

Since a few folks here recommended Common Lisp to me as the language that would "tick all my boxes", I've been doing a deep dive. Right now, I'm working through SICP again with DrRacket. The first time I worked through it with MIT Scheme MANY years ago. It's shocking how much I've forgotten.

What I like about this article is that it walks through the different "camps" of Lisp. Scheme is so intriguing to me because of how small it can actually be. I can build nearly any paradigm I want to exist. The problem is, if I were to actually go find a job where they were using a Lisp, (I hear those actually exist) they wouldn't want to use my "Result monad + match statement - railway pattern" that I've used from OCaml and Rust. So learning something that is truly "common" can make more sense.

As far as learning though, Scheme feels "just right". I've imposed a "no AI until I've found a working solution" rule that keeps my mind engaged. Couple that with a willingness to say, "I don't know that right now... I'll think about it throughout the day and maybe by this evening I'll have an answer".

[AyanamiKaine]

I can also recommend clojure. For me it has the best parts of common lisp and the best of the java ecosystem. But its also quite different from common lisp and scheme. Different enough to find some unique ideas.

Writing scripts using [0] Babashka is also really nice.

[0] https://babashka.org/

[snorremd]

As a former Clojure dev (now just using Clojure in my spare time) I love Babashka. Michiel Borkent really nailed it with sci (Small Clojure Interpreter) and Babashka. Running a custom Clojure interpreter in a GraalVM compiled Clojure app is quite clever.

Now there are of course limitations to what you can do in terms of not supporting Java reflection or the full Clojure compiler. But I've made some nifty small scripts and convenience helpers with it. And the dev experience of making these scripts is so much nicer than trying to write bash scripts. The Clojure edn syntax is super simple, and the REPL connected editor let me rapidly test parts of the code just like with full Clojure apps.

I don't have experience with other lisps, but I can vouch for Clojure being very nice. The community was welcoming and friendly to newcomers when I started learning, I hope it still is. One thing I love about the Clojure ecosystem and community is the effort taken to never break libraries. I've looked at libraries I used some ten years ago, and the API is still compatible with code I wrote back then. There is very little churn. Maybe this is because the language is largely untyped and editors only partially check "types". Having breakages in libraries you consume once every couple of months would get really tiring in Clojure land. I'd imagine the same problems would present themselves in Common Lisp and others.

[pjmlp]

I love the Clojure community, it is the only one that usually talks about the host platform in a symbiotic way, not as if they would be rewriting everything into their favourite language, like in most guest languages communities.

[zem]

people don't usually think of C as a host platform, but the python community has a similarly symbiotic relationship with C extensions.

[erichocean]

Since Java 25/Project Panama, I have that kind of relationship with C from Clojure as well.

Codex can one shot the bindings flawlessly, and the interface is significantly faster for downcalls vs. JNI.

[pjmlp]

Hence why it is such a sad story with JIT compilers in Python.

[nobleach]

I particpated in a Clojure reading group for "Getting Clojure" back around 2017. Having the entire JVM ecosystem available, is absolutely a great benefit. I even fooled around with ClojureScript a bit. David Nolen is great at making the case for both.

[jlarocco]

On a related note, there's a cross-platform Common Lisp package, "Bike" https://github.com/Lovesan/bike, that lets you use .Net assemblies from Common Lisp.

I've used it a tiny bit at work (on Windows) and at home (on Linux), and ran into one issue with "out" parameters, but otherwise it works really well.

[nobleach]

That's just crazy! (in a good way) I've been in software since 1998 and it's like I've just uncovered a whole new world.

[vindarel]

What about this one? https://github.com/dotcl/dotcl

> Common Lisp implementation on .NET. Lisp source is compiled to CIL (Common Intermediate Language) and runs on the .NET JIT — so the same Lisp image runs on Windows, macOS, and Linux across x86-64 and ARM64 without per-platform porting work.

[jlarocco]

Thanks! I don't think I've seen that one.

[arikrahman]

Now there's Jank too, the first time a Lisp dialect has reached into native world since Clasp. The way it interops Clojure with the LLVM is unprecedented.

[Jtsummers]

> the first time a Lisp dialect has reached into native world since Clasp.

What's that supposed to mean? Many (probably most if we only consider the non-toy ones) lisp implementations are "native" (compiling to native machine code, not interpreted).

[erichocean]

You can directly call C++ as C++, not via a C ABI.

[Jtsummers]

> You can directly call C++ as C++, not via a C ABI.

That's a unique definition of "native". It suggests that C is not a native language, which is going to be a hard thing to convince others of.

[yogthos]

I'm also working on Jolt which uses Chez Scheme as the compiler. https://jolt-lang.github.io

I've already got enough of JVM compatibility to run Ring apps, and have some fun libraries like a Reagent style library on top of GTK https://yogthos.net/posts/2026-07-02-jolt.html

[xedrac]

Don't forget Jolt! It's clojure built on top of Chez Scheme, which is super cool.

[waffletower]

Babashka is really nice indeed. Am hopeful for the C++ hosted Clojure dialect, Jank (https://jank-lang.org)

[Diogenesian]

The Scheme Programming Language by R. Kent Dybvig is very much worth reading after you finish SICP. Truly the same caliber as K&R's C Programming Language, and more up-to-date (R6RS). The earlier exercises aren't too tricky (except call/cc headaches), but the final chapter has some good meaty Scheme projects that will teach you a ton.

It's free online: https://scheme.com/tspl4/

[zackmorris]

For what it's worth, Scheme was the first programming class that I took at UIUC around 1995, as I recall.

I had used C++ for several years to make shareware games, so I took a test to challenge some programming courses. I vaguely recall doing well, but my advisor encouraged me to take them anyway. I'm glad that I did, because I had little understanding of theory.

Funny story: the instructor never mentioned that we could use more than one line of code. So every single piece of homework that I handed in, and every test, was one giant line of nested logic. Which worked better than one might expect, and completely changed how I wrote code from that point forward. That's how I made the connection a decade later that functional programming is akin to a spreadsheet, as are higher-order method chains and immutable variables.

I think of Clojure as being a layer above Lisp, sort of like how Swift might be considered a layer above Objective-C/Smalltalk. However, bare Lisp has problems around not quite giving enough out of the box. It's minimalist enough that developers end up reinventing the wheel for things that should probably be provided by a layer/library similar to Scheme or Clojure.

To digress, I feel that mutable variables and even monads are a code smell in functional programming since they can cause impurity. They're more of a crutch to ease conversion of code from imperative languages. However, monads can be useful to simulate every path through a program, sort of like superposition in quantum mechanics and SAT solvers. So they aren't necessarily bad, just taught incorrectly, probably because they're so hard to grok.

I'd vote to settle on a series of layers like Common Lisp -> Scheme/Racket -> Clojure/Elisp, with the final layer providing the intersection of features available from the most widely-used Lisp variants. Note that this is specifically to form a bridge from imperative languages, so research work might need additional DSL features brought forth from the Racket layer.

Edit: I forgot to mention that Scheme is a good fit for genetic algorithms, see books by John Koza (no affiliation). My feeling is that we haven't seen anything yet regarding what problems AI can solve, since it's having to do it the "bare hands" way with LLMs and pattern matching.

[sph]

I dislike Common Lisp, and I fear it keeps ruining the reputation of Lisp itself with its archaic and obtuse systems designed by a committee of dinosaurs. This opinion will attract the ire of many a greybeard. I stand by it.

If you want a Scheme with batteries included, I recommend GNU Guile. Also worth your time are Racket, Clojure, Janet.

[lkuty]

I also have started doing SICP recently with Racket and `#lang sicp`. Sometimes I skip some exercises and will come back to them at a later time. It allows me to choose when to advance reading the text or make the exercises. So far in section 3.1.3. Discovered MIT Scheme in 1996 at university, got plenty of scheme books for years including SICP, and each year telling myself that I should do this classic. I am reading the pdf version of https://github.com/sarabander/sicp because it is more practical than using the paper book. Recently I bought the instructor's version of the book.

[lkuty]

And also doing the exercises of The Scheme Programming Language 4th at the same time to refresh my Scheme knowledge. Using DrRacket as an IDE with the line `#!r6rs` to avoid using the Racket language.

[hackermailman]

In Sussman's book 'Software Design For Flexibility' he uses Match? in the pattern matching chapter to run on graphs. I think OCW archived his MIT course for the book too

[nobleach]

Yeah, guile has a library that looks close to what I want. The worry is that railway programming is an entire shift in error handling. Since it's not the standard that I've seen in the Lisp/Scheme world, I'd be forcing a paradigm that no one wants.