Racket – Lisp beyond Clojure

> Are there (m)any advantages to doing this?

[trigger warning: cynicism distilled from 15+ years of bitter tears]

More fun and better job security for the current maintainer. The former because one hacks away in the preferred language, the latter because one cannot be replaced easily by some unix geek unless s/he happens to speak the same language fluently.

One can chose from various implementations in various languages (eg: psh and scsh) but hacking your own is easy:

* Just re-implement the basic unix tools and shell semantics and invent some nifty convenience syntax and features along the way.

* Either don't document at all or document everything with at least 2 pages aimed at people who have never used a computer before. Both ways will prevent the only ones who could replace you from even looking at your "shell in X".

* Never ever do this in a typed language, write a ton of unit-, functional- and integration tests to make up for that - of course all of them completely undocumented.

* On top of your creation, invent a fragile "shell syntax like" layer to make adoption easier.

* Under no circumstances create some new abstraction layer that goes beyond shell semantics that brings something substantial to the table and is well documented.

* Enjoy the time saved because you don't have to "man $tool" anymore, it's all your code anway.

* Under no circumstances ever write in pure posix sh again - the realization that with all the stuff you've learned along the way posix sh covers 99% of the use-cases in a more expressive way will be crushing.

Link to your code? I would be very interested to see this thus far.

I have looked at avesh (CL) and xonsh (Python) because I think the future of fun *nix tooling is like libraries that implement a bash layer to like gradually move code away from shell languages. This is the sweet spot I would want in my life.

> Racket is all the promise of developer-centric power tooling that puts Common Lisp to shame.

Have you ever used a commercial Common Lisp like Allegro ?

I find DSLs to be extraordinarily powerful for writing and working with my own programs. I find them painful when I'm trying to work with other people's programs.

Making a DSL lets me construct a language to express my program that meshes with the way I think. Unfortunately, we all think differently, and what is intuitive and friendly for me is hostile and awkward for others.

While reading someone else's program that uses a DSL may be superficially easy, but the minute you try to get under the surface, you're left scrambling to understand what a given term or idea meant to the author. There is no language definition to rely on for common understanding.

There are exceptions naturally.

I know a lot of people will disagree, and that's fine of course. It's opinions all the way down.

This is addressing a question I'm interested in, but on first read I'm struggling to see the value that's being presented here.

- "parameterize" is great, but seems exactly the same as Clojure's "binding" on a dynamic variable. [Edit: modulo being "sticky" with regard to continuations... but Clojure doesn't have continuations, so it's a pretty subtle difference.]

- Reader macros are an interesting feature, but do move away from the syntactic regularity of LISP -- and were, AFAIK, explicitly rejected in Clojure

- Custodians are kind-of interesting -- but I ended up having to do some Googling [1] to find out exactly what they do...

Is there anywhere else I should be looking for a more systematic Racket/Clojure comparison?

[1] - https://docs.racket-lang.org/reference/eval-model.html#%28pa...