I feel like when I dive into LISPs like Racket or SBCL I’m presented with a very academic purist view of programming that clashes with my desire for more tangible, material apps.
I feel like I’d be able to comprehend deep computer science theorems in CL well but god forbid if I wanted to crank out a weekend web app.
Most of the books and tutorials about Racket are by academics. So people who start with those will get that impression.
But if you dig in to hacking with Racket (or another Scheme!) as a powerful general-purpose language, and to some extent ignore the "pedagogy" stuff, there's a lot of serious programmer stuff.
The CL books I've seen, OTOH, tend to be pretty practical, but also more technical than your average Python/JS just-get-me-a-job books.
A big thing to know about Lisps is that they're nigh-unemployable (other than Clojure, if you want to work in an enterprise Java shop)... so Lisps disproportionately attract the kind of people who would be programming computers even if it weren't a well-paying job.
My point of view is that if you want to use CL in your shop, you better have serious money as the people that can do it without blowing everything up are the same people that can find a good job somewhere else. Lisp is more like spell-crafting than house-building (Forth is like that too), so after a while, the system is more like a new language entirely. You have to get a team of highly disciplined engineers and it's not something the current state of the industry tend to do.
LISP to Python (and therefore a job) is really just moving the left hand parenthesis after the function name, replacing spaces with commas, discarding everything good and right about homoiconicity, and embracing a nigh sickening amount of syntactic sugar around OOP.
Give me a decent LISP programmer who is willing to compromise and I can get you a job.
Macro is the name of the game and where you go from programming the business rules using a language to directly stating the rules themselves.
Something like (def-action name ..) and it generates the whole routing handling, response generating code for you in a web application. Kinda like, but more powerful than the decorators you find in Flask.
Unfortunately it also means throwing away compiled code, in JIT and AOT form.
Still looking forward to the day Python ecosystem fully embraces it, without going through using C and calling it Python, or reaching to implementations that are 80% there and are largely ignored by the community.
Thankfully the whole AI stuff is putting pressure into making JITs part of the standard Python workflow and I am looking forward to that Python 3.13 release.
Racket is very academic, but Common Lisp (SBCL is an implementation of the CL standard) is not really academic in my opinion its mostly an industrial language. It is an incredibly practical language and its exactly what I reach to to crank a weekend webapp. Its fast and unopinionated and the repl is a godsend for the quick iteration required to do a weekend hack. I think it may just look like that from the outside due to preconceived notions of what lisps are.
CL mostly allows you to do whatever you want, at its core it is a compiled, imperative, garbage collected language, with incredible interaction and introspection capabilities and the ability to modify the language in a very straightforward way (take code, modify code). It just has a weird syntax to be able to do macros and reason about macros
Let me propose to you an idea that bridges a Lisp and a weekend web app for you: write the infamous TODO app using the React framework using a Lisp. Transpile that Lisp into JavaScript to get it to run in a browser. Depending on your level of perseverance either write that transpiler yourself, or pick one that already exists (like ClojureScript), or even just write your function that outputs JS.
I have done that a decade ago before React was even popular. Even if only the syntax is different, it was and is much nicer than writing JSX.
In respect to Common Lisp, you could look into "Common Lisp Recipes" by Weitz[2], and "Practical Common Lisp" by Seibel[1]. These are industrial-strength systems which were used to built large airline reservation systems.
Scheme is in a way more minimalist and Schemes are not as large, but this might also be give an erroneous impression because they build on the enormous experience with Common Lisp and have boiled down to the most essential parts - it is not the kind of minimalism "the simplest things that could work" but "what turned out to be indispensable in practice", which is a very different thing.
I use racket and sbcl both. I prefer sbcl. We write a lot of software in cl; it is excellent. Cannot say anything else beats the debugging experience unless really low level, but for embedded we use c code gen from cl anyway.
Yeah, different use-case really. Personally I enjoy the more “academic” languages, like the LISPs and Haskell. I play around with them for things like Advent of Code and small POCs, but _rarely_ anything approaching a useful/production-ready application.
