4 ms·
There's a BIG difference in ecosystems if a system starts out with pervasive threading or doesn't. In a slightly different domain, I saw this back when I was d
by hga 13y ago
There's a BIG difference in ecosystems if a system starts out with pervasive threading or doesn't. In a slightly different domain, I saw this back when I was doing NT programming in the '90s. From the start it provided threads and plenty of thread safe stuff (and plenty not, including the MCV++ Standard Template Library in 1997, although that was mostly of an initial botch of the port from the HP? code), and this made quite a difference compared to trying to write threaded programs for UNIX(TM).
If you're not going to limit yourself to copying paradigms like the Actor model I argue you're going to be in for a world of hurt, even as your ecosystem matures, because you'll almost certainly have non-thread safe stuff from the days when the community wasn't considering threading.
So all I'm saying in this argument is that Common Lisp is traversing this painful path, and will never be as optimal as it might be, because when it was cast into concrete in 1984 threads weren't part of it.
The Clojure argument for standard data structure syntax-literals, and strict limits on reader macros, is indeed legibility, defined as portability between humans. I think it's an issue, but one that I think we'll have to agree to disagree on. Although I don't see gaining CL compatibility as a goal, the foundations of the languages are too different (functional vs. multiparadigm including but not limited to functional).
I agree that age itself isn't a good criticism, I was pointing out how Common Lisp's extreme age has resulted in issues, and "age criticisms" could be interpreted that way.
This goes all the way back all the way to the very first late '50s LISP, e.g. while I personally like them, classic examples are Contents of the Address Register and Contents of the Decrement Register (car and cdr) of the vacuum tube IBM 704. More consequential are things like Lisp-2 vs. Lisp-1; maybe it's just a matter of taste and not having written enough macros in my career but I prefer the latter.
Hmmm, to sum up, one argument for Clojure is that we now known enough to create a more restrictive dialect and benefit from the good taste of Rick Hickey and now others who are helping to carry the language's torch. Callow youth though he might be, mrottenkolber is spot on when he says it's an opinionated language, and that'll certainly mean among other things that it'll not be to many experienced Lisper's taste (probably easier if you're a Schemer, though).
I harp on SMP programming because I find it, and the functional programming solutions to it, very interesting, not to mention it's just plain better for writing robust software. Closure seems to have done a good job using the latter to address the former, and gaining those other minor details guaranteed FP grants you.
- agentultra 13y agoAnd yet it's trivial to write a highly multithreaded application with STM in most CL implementations today. If Clojure was less inclined to differentiate itself from other Lisps and co-opting the future of the language I believe there'd be far less zealotry on both sides of the fence. IMO Clojure is just fine. I don't see the reason why it needs to persist CL FUD in order to make its case. They're both very practical implementations of Lisp after all.
- Mikera 13y agoFWIW, I've been in the Clojure community for a few years and see almost zero FUD about Common Lisp. The atmosphere in the Clojure community is much more about pragmatism than zealotry. Mostly, I see a healthy respect for other Lisps and a recognition that learning from traditions is a good way to build good things for the future.
- sdegutis 13y agoBeing in the Clojure myself, I'd say the aforementioned "healthy respect" and "pragmatism" come from the fact that we all probably have migrated through at least a few languages before ending up at Clojure, which gives us a sense of perspective that keeps most of the zeal away.
- lispm 13y agoCommon Lisp implementations deal with threads since day zero. The non-threaded standard has not prevented dozens of implementations to provide threads. Common Lisp has man different full implementations. Clojure is basically just one real implementation. Clojure limiting the use of reader macros is just another example where somebody is telling me how I should use a language. It's basically as in Java. Common Lisp and Lisp in generally has favor a different root: give power to the user. Why stop there. Why not provide a fixed amount of macros and remove the user-written macro facility from the language.
- hga 13y ago"Common Lisp implementations deal with threads since day zero." Really? Name them. Granted, I'm not sure myself, since I left the community in the fall of 1984 when I left Goldhill (which ran on 16 bit x86 and 640KiB - minus what DOS extra took up, so not only did it not do threading, it didn't even (initially, while I was there) do lexical scoping (!)). But I heard it took some time for Symbolics to adopt Common Lisp (installed base problem), and I don't know about the other early commercial ones. Allegro Common Lisp is rather early to have had threading on the PC platform. Did the Macintosh do threading as of 1987? What about Lucid? A quick look at the indexes of the users guides for Liquid Common Lisp, which I understand to be its current version, don't have the word thread in them.