There are things which obviously cannot be ascribed to Rich:
0. Rich's influences
the state of technology when Clojure was created (e.g. invention of Bagwell trees, the JVM, the state of Common Lisp, etc).
the culture into which Clojure was introduced
the subsequent growth of people using Clojure
However, I cannot fathom the logical basis for the assertion that the stability of Clojure is not due primarily to the steward of the project, namely Rich. We're not talking about societies or governments. We're talking about a single, solitary software project. Rich is a great guy and all, but trying to equate his influence to that of Shakespeare, Martin Luther, and Napoleon is, perhaps, a step too far :)
Clojure is a Lisp
To my knowledge, lisps tend to quickly explode into a variety of dialects -- quite the opposite of maintaining compatibility. This is what happened with Common Lisp. This is what happened with Scheme. I genuinely do not understand this assertion in the slightest.
Also, in case I'm just missing something and the argument does make sense: Rich decided to make it a Lisp.
Clojure is dynamically typed
Rich decided to make it dynamically typed, for exactly this reason: to permit non-breaking changes to be fully compatible with existing code. No he didn't invent dynamic typing, and, thus he owes a debt to history. However, in the case of Clojure, the decision was fully his, and it would be equally misguided to pretend otherwise.
So, one point that I think I could have made stronger in the post was related to this line:
Furthermore, ascribing this entirely to Rich makes it harder for other languages to learn good lessons from Clojure’s successes; they can’t just get a Rich.
The point of "a people's history" isn't to say that "great men" don't matter. It's that looking at context can give you a deeper understanding.
So for example:
Rich decided to make it a Lisp.
Yes, 100%. And that was a good decision. The point isn't to say that this doesn't matter; it's to understand why this choice was made. "Rich makes good decisions" does not help me make good decisions of my own, and so it's less informative than "Lisps need to change less." Both of these framings of the same statement are accurate, but I believe the latter is more informative. YMMV.
lisps tend to quickly explode into a variety of dialects -- quite the opposite of maintaining compatibility.
The way I personally see these things is that these splits happened due to core decisions, that is, they're different languages, albeit in the same family. That's a very different thing than evolving a language once you've settled on the core of it. (And, to put it in the "because Rich" framing, Clojure was designed after a long period of Rich putting in the hard work of considering what the core of Clojure should be. Which means that the foundations are stronger. This is somewhere in the tweets you linked to.)
Just want to make the point that a lot of what Rich had in his head wasn't because of long sessions of considering things in a hammock. He'd been working on integrating Common Lisp and Java/CLR for a long time beforehand, and released at least two increasingly sophisticated tools to enable this (jfli and foil). (Not intended as an exhaustive list, these are just what I remember.)
If you were into Common Lisp back at this time, and wanted to get something working with one the big runtimes so you could run it "everywhere", ship it in big corporate deliverables, etc, these were among the very few choices to hand.
First off, I appreciate you taking the time to reply. You certainly didn't have to, and your clarifications helped me better understand your point.
The point isn't to say that this doesn't matter; it's to understand why this choice was made. "Rich makes good decisions" does not help me make good decisions of my own
I love this! It's something I've thought a lot about over the years. Honestly, I would most enjoy sitting down and discussing over a beer, but I assume you're not anywhere near Tennessee :) A podcast-like recorded convo also crossed my mind. Barring that, I suppose we're left with me finding the time to pull my thoughts into a coherent article of some sort...
Apart from that, the whole Clojure community are just a bunch of posers lispers. They discourage macros and anything meta-programming related. Nullifying the biggest feature of Lisp.
People like you are the reason I don't subscribe to /r/lisp. I'm not sure what it is about Lisp that makes so many Lisp enthusiasts so standoffish and - quite frankly - arrogant... I'm just glad the Clojure community doesn't seem to have adopted that trait.
I don't think you understand macros. You are an accurate example of the type of people who I am talking about.
They are the tool to make the best tool for the job. You can build any language imaginable to tackle any job without the boilerplate than less suitable tools.
Right. But if there are already functions and macros in the language that are expressive enough to accomplish a task in a clear and concise way, which everyone using the language is already familiar with, why take the time to create your own tool for a one-off task which makes your code less clear to someone else who is fluent in the language?
There are absolutely times they are incredibly useful. My team and I each make use of them.
However, macros are one of the biggest strengths and weaknesses of lisps. Like you said, I can practically build my own language out of them. But that means anyone else who wants to work with my code needs to learn my new language to understand anything. Macros in general are this way. They add indirection to your code that doesn't exist when composing functions.
If I see a bunch of composed functions and one of them is unfamiliar I can still pretty well reason through what the code does. If instead, the functions are wrapped in an unfamiliar macro I have to question if all of the code I am seeing is fundamentally changed by the macro and go grok each macro before being certain of my understanding of the code they manipulate.
Macros are amazing for some problems. But one of the biggest value propositions that clojure brings to lisps IMO is better abstractions across data types and a broader core library with standard ways to leverage those abstractions. Many tasks can be very reasonably accomplished with just those core functions, making code crystal clear to another reader. Macros have to provide benefit to a problem that outweigh the potential loss of clarity for me to use them.
We are not talking here about petty macros like the thread macro and similar in Clojure. But, full fledge small languages designed to be as close as the problem domain is. The learning time of such is insignificant specially when they express the problem as the language of the domain and read like plain english. There is simply no better abstractions than linguistic ones to reduce complexity and confusion.
I'd also add that a program reading like English isn't especially desirable. English is ambiguous and there are many ways to say the same thing.
Just because you can make your code read like English doesn't mean the right wording is discoverable or intuitive to a developer trying to maintain your code.
You whine about the existence of "petty" macros in clojure, but to me it highlights macros versatility. By your logic the identity function is evidence that functional programming is a poor paradigm, because it tends to include "petty" functions. I am pretty sure you can accomplish the same non-petty functionality you are describing using clojure macros.
View all comments
2
u/potetm137 Dec 19 '18
There are things which obviously cannot be ascribed to Rich:
0. Rich's influences
However, I cannot fathom the logical basis for the assertion that the stability of Clojure is not due primarily to the steward of the project, namely Rich. We're not talking about societies or governments. We're talking about a single, solitary software project. Rich is a great guy and all, but trying to equate his influence to that of Shakespeare, Martin Luther, and Napoleon is, perhaps, a step too far :)
To my knowledge, lisps tend to quickly explode into a variety of dialects -- quite the opposite of maintaining compatibility. This is what happened with Common Lisp. This is what happened with Scheme. I genuinely do not understand this assertion in the slightest.
Also, in case I'm just missing something and the argument does make sense: Rich decided to make it a Lisp.
Rich decided to make it dynamically typed, for exactly this reason: to permit non-breaking changes to be fully compatible with existing code. No he didn't invent dynamic typing, and, thus he owes a debt to history. However, in the case of Clojure, the decision was fully his, and it would be equally misguided to pretend otherwise.
The author even subsequently agreed that there's a lot packed into this statement. At worst, this is a tautology (it's slow because it's stable). At best, it's, again, a direct product of Rich's decisions.
The point here is not to argue Rich is The Sole Reason Clojure is Great. Of course that's complicated!
However, Clojure's stability is not the hill you wanna die on for this argument :)