NoahTheDuke

Thanks.

Congrats! This looks super cool.

Are there any plans for exposing a Clojure API? Given that it's implemented in Clojure, seems like it would be a natural fit. Interop with Java is nice but can be cumbersome compared to the more natural calling conventions and idioms (threading macros instead of `..` builder patterns, etc).

I am sorry, but I have to disagree.

You disagree that they enjoyed the article?

Reader macros/literals allow for explicitly differentiating between built-in data types, and provide semantic meaning to otherwise indistinguishable forms. For example, defining a function:

In Racket, you write `(define (foo arg1 arg2) (+ arg1 arg2))`. Why isn’t `(foo arg1 arg2)` evaluated as a function? It’s a list and it isn’t quoted, so it should be evaluated. However, `define` is a macro (I think, might be a special form), so that list isn’t evaluated and doesn’t have to be quoted. That violates the basic tenant of “unquoted forms wrapped in a list are evaluated as fiction calls.”

In Clojure, you write `(defn foo [arg1 arg1] (+ arg1 arg2))`. The [] is a reader macro, a vector literal. It communicates that it’s not a function call but simply data (in this case, a vector containing two symbols).

Maybe I’m just used to it but I find this stuff really helpful.

don't mix and match words and symbols

This is an interesting design decision. Why don’t you want to combine them?

Other workflows exist; pretty silly to act like you’ve found the One True Way.

I roughly agree with you but in your deps.edn example, how would you like the tool to respond? Your map/dictionary/object has an uneven number of forms, so what else would you like it to say?

Adam Neely is fun “pop science” about music but this one in particular is a real treat. Love the cover of the song by Martina de Silva here too.

I just tried breezethat and had to scroll past 6 ads (two screenfuls on my iPhone 10) to see a single result. I know ads are necessary but this is punitive.

Wow, massassi.net is quite a trip through time. I spent many many hours on your site, playing Jedi Knight with friends and randos through GameSpy. Endless hours of entertainment toying with JED, trying to perfect my own levels, or installing various mods and texture packs.

Thank you for the effort, you gave me quite a few cherished memories.

Clojure has that built-in and it’s great. Works wonders when testing things too: write a small test in a comment block and you can edit/evaluate a function then move to the comment and see the result immediately.

I love that “hacking language learning” turns out to be “mostly do what babies do”: consume as much content as possible. Babies take it one step further by trying things without embarrassment or any attempt at “getting it right”, only focused on raw communication.

Not to denigrate the efforts of folks who study and practice “the act of language acquisition”, I’ve just been surprised and delighted to watch my now 2 year old daughter learn to speak, which has made me think about how different her experience of “learning a language” is from all of my poor attempts at learning foreign languages.

I wonder if a `loop`/`recur` construct like the one Clojure has would help here. Allows for closing over data without having to pass everything into a recursive function, and can handle more complex looping constructs without having to write an explicit "for loop".

I suspect they’re using it the same way it’s used on Less Wrong[0].

[0] https://www.lesswrong.com/tag/rationalist-movement

For all their sneering at traditional philosophy, rationalists (and specifically the Less Wrong community) love to rewrite traditional philosophy in techy terms while missing most of the underlying meaning and depth. For examples, large portions of The Sequences are Plato’s The Republic but worse or Wittgenstein’s Philosophical Investigations but worse.

What do you think I said?

The whole point of that section is that he wasn't there. He'd taken time away to get a Masters of Fine Arts, and this paragraph was his reaction to re-entering the world of programming and software. Coming back after 5 years and seeing that the journal he'd started that was focused on symbolic computation using Lisp has now expanded to include using other languages doesn't mean Lisp is forgotten.

I browsed the titles of a bunch of the articles published by the journal after the name change, and most of the were language agnostic but still lisp-adjacent and potentially lisp-relevant. (For example, Volume 12 Issue 1, the second year with the new name, has multiple articles about call/cc using demonstration languages.)

I like the writing style and voice in this essay. I disagree with some of the assertions but I enjoyed my time reading, which doesn’t happen a lot with most tech-related essays.

I will say, however, that this paragraph felt like sour grapes:

As examples, the scientific journal Guy Steele and I founded called Lisp and Symbolic Computation (LASC) had been renamed Higher-Order and Symbolic Computation (HOSC), and my primary scientific conference called Lisp and Functional Programming (L&FP) had been renamed the International Conference on Functional Programming (ICFP). I was discouraged for two reasons. One was that during the 1980s when functional programming researchers had few outlets, many of us Lispers kept the lights on at L&FP for them, and later when Lisp was on the decline, they shut the door. And the other is that this seemed to signal that my field of inquiry had been deleted by the academy.

All that’s changed is that Lisp isn’t primary anymore; they are both titled to allow other languages and other media to contribute to their respective focuses. Common Lisp is a good language but it’s not the final language nor even the final “programming medium”, so acting like it is artificially limits both Common Lisp users and future language designers who could all benefit from that cross-pollination.

Now maybe the change of names is shorthand for lisp actually being excluded from the journal and conference, which nullifies the above, but without doing any research at all lol, I doubt it.

This jaw-droppingly moronic.

It can be slightly inconvenient but doesn’t feel moronic to me. It means that except for the built-in functions, everything can be traced to either a definition or an import. Makes tracking code much easier.

Another one is having to import everything you use.

The alternative is what exactly? Have the entire standard library exposed at once? Make all modules create non-conflicting names for exported objects, so that the json parse function has to be called json_parse and the csv parse function has to be called csv_parse?

Seems less than ideal to me.

Which is another name for unit tests.

I listened to all of Worm (https://parahumans.wordpress.com/) with TTS and while it wasn’t ideal, it worked out well enough that I got a full understanding of the story. I’ll note that I did this before the fan podcast to read the whole story lol. That’s a much better option now.

If a tool attracts enough ire that such arguments arise frequently, then a non-zero number of people are dissatisfied and could be satisfied by other tools. That is worthy of discussion.

Additionally, it is cathartic (and occasionally even productive) to complain about the warts and sharp edges of a popular tool, especially when the tool is the overwhelming the tool of choice in its domain.

This is a cheap shot. If you have a point to make, you should make it directly.

You mean you struggle to install Clojure on a Mac? Clojure maintains a tap with Homebrew: `brew install clojure/tools/clojure` Leiningen should also have one but I don’t have that link on hand.

I wrote it up here: http://noahtheduke.github.io/posts/2021-10-02-from-elegance-... I'm not a great writer, but hopefully you enjoy it!

I also found a small bug, that you'll want to use `(elt s (+ x 7))`, not `(+ x 8)`. `elt` is 0-indexed, so first and last of an 8 element list will be 0 and 7.

Of course. I don't mean to imply that optimized Clojure could match optimized Common Lisp, just that the disparity wouldn't be quite as stark. For truly speed-focused code on the JVM, you have to write speed-focused Java.

Your post is a lot of fun! I have a fondness for these kinds of deep dives. That being said, I feel like comparing the initial unoptimized Clojure code to highly optimized Common Lisp is kind of unfair. I wonder how fast the Clojure code could run if given the same care. Maybe I'll give that a try tonight!

No, it doesn't. It means not privileging profits at the expense of people. It's possible to have profit as a goal without hurting people (in this fashion).

Oh that’s very clever. Makes me wish javascript/Typescript had macros so I could define this all in a single call.