Thumbs Down for Clojure


Historical note (Jan. 7, 2014) – This ancient post still gets several hundred to a thousand page views per month! And, unsurprisingly, the Clojure community still replies to the criticisms therein with… only insults. This is what comes of a product fundamentally brain-damaged at birth.


I find Clojure revolting.

It is the most explicit to date abandonment of the age-old Lispers’ Dream, “Lisp All The Way Down.” Clojure is the antithesis of the Lisp Machine. Instead of a crystalline pyramid of comprehensible mutually-interlocking concepts, behind every Clojure primitive there lurks Black Magic. The Clojure user who is missing some routine or other will run crying to Java for help, rather than implementing the feature himself correctly – that is, as a natural part of the entire language, built on the same concepts. Clojure pisses on everything I’ve ever loved about Lisp. It rejects even what little consistency and intellectual rigor there is to be found in an abomination like Common Lisp.

Clojure is the False Lisp, which Reeketh of the Cube Farm. A Lisp unworthy of the name; one which encourages users to pepper their code with calls to opaque routines having no underlying Lispiness. A Lisp which barfs Java stack traces. It promotes – no, mandates - the use of undigestable foreign matter in Lisp code: primitives on which you cannot pop the hood to reveal intelligible innards.

I don’t care if everybody really is more productive in Clojure than in Common Lisp. The latter is not my standard of comparison (Symbolics Genera, the state of the art, is. Or, if you want something that is distinctly inferior but is currently available on the market: Mathematica.) Clojure is the gutted and zombie-reanimated corpse of a dream.

The cult of Good Enough which seems to pervade all of modern computing has finally chewed its way through to the Lisp community, with Clojure as the result. I am tired of this abomination being hailed as the future of Lisp. Aficionados of real Lisps, such as myself, will keep hoping, dreaming, and working on systems which do not betray the original virtues of the language.

Symbolics Genera remains the gold standard of programming systems. Though largely forgotten, it can never be un-created. My standard of comparison for any technology will always be everything previously achieved by mankind, rather than what is available on the market today.


Edit: Update.

This entry was written by Stanislav , posted on Thursday June 25 2009 , filed under Distractions, Hot Air, Lisp, NonLoper, SoftwareSucks . Bookmark the permalink . Post a comment below or leave a trackback: Trackback URL.

130 Responses to “Thumbs Down for Clojure”

  • Eric Normand says:

    Thanks for this breath of fresh air. There’s a lot of hype now about Clojure. It’s great to hear your honesty.

    I have resigned myself to what I can find that is practical. This is unfortunate, because I find writing my own OS/Language impractical at the moment. Oh, to go back to school and be paid to experiment with language design. But the world calls to me with much practical detail.

    I think Clojure is entirely built on practicality. use JVM so that it can run on any machine. You get object system, libraries, gc for free.

    There is innovation, though. It is not Lisp all the way down, unfortunately, but the large number of aggregate data types (hash-maps, sets, lists, vectors) makes it very useful. I hope to use these idioms (and more) in my own language some day in the hopefully not-too-distant future.

    The evaluation semantics are a bit icky. Looking up java classes vs vars in the current environment give lots of bugs. I dont like it a bit.

    What I think people don’t realize is that in the long run, coming up with a system from the bottom up, based on sound foundations, is much better/practical/powerful than the hackish systems most people come up with.

    Oh, well.

    Thanks again

  • Martin says:

    Lisp all the way down is a great idea. It’s amazing that others – some would say *everyone* else – have gone away from having cdr be cdr all the way up, and supplanted the similarly elegant consistency of having “mov” and “JSR” all the way up with the jarring switch to “=” and “goto”. Fucking retards.

    Please, continue your work “searching for the real Lisps” (damn OJ for trivialising that phrase) and Lisp all the way down. Who can deny the obvious sense of high-level languages compiling directly to the processor instruction set is the most correct way to design a language^Wplatform^Wfairyland^W”real” Lisp? It is just what the designers of Java (stupid, clearly ignorant of Lisp’s elegance), Smalltalk VMs (computing lightweights), MS CLR/DLR (well they never get anything right), and, well, every other language in the world including every other Lisp besides Genera.

    Let us know when you’ve got something workable to talk about, as we wait with baited breath. As you said before, a multi-GHz resurrected Lisp machine descendant. I assume you’re months away from announcing, at most.

  • Bradford says:

    Wow, thanks for a new perspective on Clojure. I’m trying to find ways to include more functional programming in what I do in my day job, within the boundaries I’m given :) I was considering Scala or Clojure, neither of which are pure, granted.

  • [...] This post was Twitted by seantindale [...]

  • Tim Dysinger says:

    I use clojure for real work. Sorry you don’t care that I am productive. I do.

    Instead of bashing clojure with unprovable statements and no examples, I would ask you to provide examples of your vague claims of shity-ness. Most of what you say here I do not agree with.

    Your article is 100 % emotion and zero % arguments.

  • Serge says:

    Stan, you’re just sad here.

    You know damn well that there’s no chance in hell that your plan for a full new Lisp machine all the way down will work, so you’re bashing an attempt at bringing Lisp to the 21st Century.

    I like you as a person, but Rich and the Clojure community have done so much for programming by bringing people into the lisp community, and all you can do is flame them? What actual work have you produced towards even your own goal (nevertheless the more grand schemes you have to writing an OS)?

    The argument of “good enough” has a long history in the Free Software community. This is the iterative process.

    Even for someone who never uses Clojure, I doubt seriously if the next Lisp doesn’t borrow ideas straight from Clojure. It’s the iterative process and it’s at work. Thank God for Clojure, or else Lisp would be continuing its slow death.

    As for your arguments against the JVM- no one is stopping the other Clojure ports, to the CLR and Javascript. If you want to write a new Clojure backend, no one will stop you- you might even get support.

  • fogus says:

    “Though largely forgotten, it can never be un-created.”

    But it certainly can (and will) be re-created… poorly.
    -m

  • Raoul Duke says:

    not sure i totally agree, but i for sure love the fact that you are passionate about it, and passionate about trying to get good things (e.g. as opposed to somebody who is passionate about using C for everything, say). keep it up!

  • Jakob says:

    Is this serious or hyperbolic parody? I’m seriously asking.

  • Chas Emerick says:

    @Eric:

    Eh, don’t get down on it. Purity (or even “purity”) rarely counts for anything out in the real world, and can often get in the way (think what one would face trying to get a Loper OS-based application/system into a customer’s door, for example).

    IMO, (biased though I might be, being a Clojure contributor, however slight) Clojure isn’t hackish at all. Or, perhaps it’s as hackish as every other lisp out there that has a backend written in some lower-level language (um, all of them, I guess, except for the rarefied Genera?). Clojure’s just happens to be JVM bytecode. *shrug*

    For those who are curious about Clojure, and want a comprehensive yet high-level overview, check out the slides from Rich Hickey’s tutorial presentation at this year’s International Lisp Conf.:

    http://clojure.googlegroups.com/web/tutorial.pdf

  • jt says:

    LIsp had its problems on the Web Server arena. First, CL-HTTP, which was very complete has a very bad license. This changed, but it’s impact has been barely noticed.

    I find it odd that the potential is there if people only picked up the pieces – then we wouldn’t need Closure.

    I always watch – completely baffled – the amount of energy that has been placed in far, far inferior designs, such as Python or Ruby.

    Common Lisp and Scheme are really a sociological case-study. Being from a different culture, they were shunned. Only now is the world at large begining to understand the virtues of functional programming (but I have to say that the ML camp has come out wining – see Scala, F# – Haskell is an exception).

  • jt says:

    I’m sorry, on my post I mentioned that “CL-HTTP *has* a very bad license.” I meant “had”. Please tale notice.

  • Question: If Symbolics Genera isn’t resurrected, what would your dream language look like? “Lisp all the way down,” sure, but what would you have in the standard libraries? Would the syntax be the same? What about the naming? car/cdr or first/rest? Hygenic or nonhygenic?

    I ask from genuine curiosity — I’ve heard lots of different ideas about what people want to code in, and it’s always interesting to get a new one.

  • I don’t use Clojure, but then I haven’t really used Lisp for anything practical in years. If someone were to come up with a practical, well thought out, and modern Lisp then this might well change. As it stands every Lisp that’s available today can be described as “the gutted and zombie-reanimated corpse of a dream.”

    Given that Lisp really isn’t that interesting, from a practical or research point of view. It probably never will be again. The sad fact is, there probably isn’t a “future of Lisp”. Not one you’d want.

    Happy dreaming though.

  • I spent some time looking at Clojure (and Scala as well) back before I finally resigned myself to having to rewrite a bunch of libraries to escape Java (and started doing it…a VM that forces null pointers into every possible corner is a practical joke of astonishing subtlety and malice). You’re looking at it wrong. It’s not meant to be a serious Lisp. It’s only cosmetically descended from McCarthy’s original idea. It’s an attempt to terraform the wasteland of the JVM. It fails, of course, but it does make it at least somewhat less likely that geysers of molten arsenic will pour through your floor at 1AM.

    It’s a shame that most languages designed today refused to learn the lessons about language designed gleaned from the efforts of the 1960s.

  • Jeo says:

    Perhaps Clojure is not “the future of Lisp.” But can you begrudge it being the future of Java?

    The JVM has an enormous opensource ecosystem. For those who want to use it, what’s wrong with giving them a decent language to play with?

    In the meantime, continue your efforts, and win in the end.

  • Chris says:

    You know, I used to think this way about lisp a long time ago. I (still) love it’s theoretical cleanness, it’s purity, and the fact that it can express any concept in programming and computer science.

    Eventually, I realized that purity counts for nothing if you can’t get anything done with it. And I can’t get anything done with current lisp implementations. The reason for this is because they don’t live in the real world, they live in a dream land that longs for Lisp Machines, and they want to hold their underlying system architectures and OSes at arms length. With that, lisp has stagnated, and there hasn’t been any real innovation in the lisp community for decades now, and CLOS is still a verbose, unusable pile of crap. Why do you think people like Peter Norvig, one of the great lisp masters, switched to python?

    Take your whining about Clojure and purity and shove it, man! Thumbs down for you and all the lisp community who have their heads up their butts about purity at the complete expense of practicality.

  • Luke vdH says:

    I haven’t seen this much angst about a change in the way things are done since the DOS developer people got invaded by Microsoft and their new-fangled Windows OS…

    Would have been a far more useful article if you had actually compared the differences and given us a reason to hate Clojure other than “I don’t like ‘fake-geeks’ invading my niche-market and making it more usable for more people.”

  • André Thieme says:

    Aah, the dead body is still twitching ;-)
    What you are doing is to some degree misleading. You are talking about Clojure when you in reality mean its current implementation. Some may think that you were talking about the language Clojure. That however can be implemented in principle on any VM. For example in the VM of Allegro CL, or in a Scheme VM, or in the one of Python, Erlang, etc…
    Or someone could provide a VM unique to Clojure. Now Rich Hickey has simply chosen the one existing VM that gave the best target for Clojure: the JVM.
    By doing that he could save lots of efforts in writing the VM itself. Other Lisps had to do that, with a few exceptions, such as ABCL. It also means that there are advantages and disadvantages with the current implementation of Clojure, like with everything else in this universe.
    In our current environment (world) a Lisp as you suggested simply is not fit enough to survive. Clojure is developing to become the strongest Lisp today.
    You are free to implement your own VM in which you host Clojure if you wish. Then the VM may exactly work as you want.
    People with real understanding of what Lisp is understand of course that the underlying VM is not what decides if the languages that are implemented on top if it are Lisps or not. Your strawman arguments only appeal to people who don’t have a deep enough understanding or who ignore that for psychological reasons, such as anger about a new Lisp outdating CL.

    • Aravindh Johendran says:

      ——————————————————————————–
      André Thieme says:
      June 28, 2009 at 9:32 am

      Aah, the dead body is still twitching ;-)
      What you are doing is to some degree misleading. You are talking about Clojure when you in reality mean its current implementation. Some may think that you were talking about the language Clojure. That however can be implemented in principle on any VM. For example in the VM of Allegro CL, or in a Scheme VM, or in the one of P—–ython, Erlang, etc…
      ————————————————————————–

      DISCLAIMER: I do like clojure and i find that some of the concepts are expanding my thinking. Rich Hickey’s efforts are awesome and I appreciate his efforts and the communitiy’s. Most parts of clojure are beautiful lisp.

      I feel André Thieme’s comment may not be accurate. There is a LOT of Java that seems necessary inside clojure code. Everyone avoids talking about it and it seems maliciously hidden when people talk about clojure being a lisp.
      All the Integer and String functions for example. Writing Java is being encouraged using the Java interop mechanisms instead of wrapping everything under lisp macros. Rationale being everything under the sun doesn’t have to be made to look like lisp. Sure ….. but have java inside lisp code ?? Java is UGLY how much ever cool interops they add in clojure.
      Rich Hickey talks about why the JVM is awesome and clojure hugs the JVM as platform, but the truth is that Java is unavoidable inside clojure once you want to add more String, Date, integer functions and so on. Everything from the type system to exceptions. Inside the repl, I love to look at the types of some return values. All of them are exposed as Java classes in clojure. It doesn’t have it’s own proper type system, or at least shows them to me in terms of Java.

      One CANNOT do anything significant work in clojure without knowing significant amount of Java and JVM’s inner workings.
      And I do not even want to go into all the friggin XML that one has to encounter because of it’s pervasiveness in Java/JVM world.

      As for clojure being written on top of cl, scheme, erlang, pythis, etc ……… what? you are going to add interops to all of these languages? Nice. I will now have portable code.

      —————–
      Sorry, I had to vent. Clojure is awesome but it has it’s issues

      • Aravindh Johendran says:

        sorry about the apostrophes in the wrong places and other such grammatical errors

  • Kaveh says:

    Only Geeks use Lisp. And not so Geek ones will get things done!

  • Hot Giraffe says:

    There was once a wise young man who tried all kinds of implements to tend his garden – spades, hoes, rakes, and much, much more – and found them all lacking. Well, there was an ancient rusty shovel in his shed that would fit him just right, except it missed the most part of the handle and could not be easily repaired. The young man then put all his skills to the task of re-creating an old shovel, while secretly smirking on his neighbours who all used the much inferior implements. To do this right he needed first to produce an identical alloy for the blade, to forge it just right, to grind it just right (the whetstone also needed to be produced somehow), to find the right tree for the handle’s wood, and many, many more things that ought to be done just right.
    Finally he had his shovel made. He took it in his hands, plunged the blade in the ground, put his foot on it, and died of old age with a happy smile on his lips.
    Decades later a wise young man looking for an implement to tend his garden found an ancient rusty shovel in his shed.

  • [...] track and talk about a post that appeared as a blip on Reddit a few days ago. It’s called Thumbs Down on Clojure and it basically denounces Clojure as a false Lisp because it interfaces tightly with Java and so [...]

  • Frank Davis says:

    This is like a Nun giving thumbs-down on the Jackass movies: he’s entirely the wrong audience for the product, so of course he’s not going to like it.

  • Bram says:

    If you dislike Clojure that much, I think you won’t like newLISP either: http://www.newlisp.org/index.cgi?page=Differences_to_Other_LISPs

  • Jared says:

    “Clojure is the gutted and zombie-reanimated corpse of a dream.”

    Wow. Erik Naggum, back from the dead. This observation may be true, but while you were “hoping and dreaming” someone decided to figure out how to make Java suck slightly less (and write HUGE concurrent systems…). Is that really so terrible? Have you brought your child to life yet?

    I was about to criticize and say “OK. Show us what Symbolics Genera can do. Let us download your App or see your website built in your own Lisp” but it looks like you are working full tilt at creating something beautiful and lasting with Loper OS.

    I found many of the ideas in Clojure (esp. immutable data structures and the use of Bagley’s Hash Map Trees, STM, etc.) to be inspiring but the dependency on the JVM is a big non-starter for me. I’d like to write native apps or CGI with a short startup time.

  • JCG says:

    Hmm. I’m rather fond of Lisp, oscillating between preferring SBCL and Dr. Scheme, but veering towards the former with Slime. When using Clojure, Slime (once I finally configured for this correctly) felt decent enough. I can say that while a few of the non-Lisp things about Clojure are poorly justified, e.g. vectors to hold arguments and commas as whitespace, it does what it claims – safe and simple multi-threaded programs of succint, consistent nature interspersed with direct Java when needed. The internals are well done and lucid to read. Honestly, I find it difficult to complain about Clojure when its real competition in the programmer marketplace is Python, Ruby, Groovy and Scala. It establishes for the folks in the mainstream many good things, e.g. removing fear of parentheses, safe use of multi-core boxes and removing the tendency to think that all problems are to be solved with mutating object-oriented method calls. It’s a Lisp dialect influenced by the JVM environment Hickey chose to utilize. If one needs to generate Java classes, Clojure is an expressive way to accomplish it.

  • stand says:

    I suspect that your hypothetical users who “pepper their code with calls to opaque routines” are not in fact likely to use clojure. There are plenty of un-lispy alternatives for them to use that don’t have all those confusing parentheses.

    Don’t let the perfect be the enemy of the good.

  • ian says:

    i can’t believe nobody’s given stan proper kudos for how uproariously funny this article was. bravo, stan…adding you to my feeds.

  • [...] "Clojure is the zombie-reanimated corpse of a dream…" -which still makes it better than the alternatives!! http://www.loper-os.org/?p=42 [...]

  • [...] It’s OK. I only recently just came to terms myself with the fact that the Lisp Machine had died 20 years ago. http://www.loper-os.org/?p=42 [...]

  • [...] Reeketh of the Cube Farm" http://www.loper-os.org/?p=42 [...and (2) do you really think anyone in a cube farm will admit [...]

  • [...] oh, somebody woke up the Lispers and told them about Clojure… we’re in trouble (here, via @cbeust) — yes, and somebody woke up this zombie rant; I’m looking at you, [...]

  • PheliX says:

    It reminds me of http://en.wikipedia.org/wiki/Turtles_all_the_way_down
    There’s always some magic behind it, instead of world implemented in itself.

  • [...] on the Java VM (think LISP). Stay tuned for our own book review on this topic. You can argue that Clojure isn’t pure, [...]

  • DigitalGhost says:

    I’m not sure whether the unholy alliance between Java and Lisp is good or bad, but one not well-known and really hilarious misfeature of Clojure is: it actually isn’t very practical.

    It’s hard to install.

    It’s hard to invoke.

    The distribution is pathetic. Well, yes, it has a content-free README that has not one line of instructions.

    They haven’t really figured out shebang beyond a few pathetic attempts. Apparently, no one had an actual useful utility that needed shebang. Does not one Clojure script exist? (And don’t point me at that old Clojure wiki page that mentions shebang but never figures it out.)

    It really seems like a big hoax. Over at Clojure sites there is nothing but people breaking their arms patting themselves on the back about how much they have accomplished. Huh?

    I have some news for the Clojure developers: making it “as easy to run” as Java EE is not going to be good enough. No one is going to bother with it if it’s only useful when loaded into your application server. Oh, great, it’s better for JBoss than Java. If I hire a team of people they can keep it running on Tomcat. Whee!

    By downloading multiple different distributions, including one which was silently withdrawn, I was able to put together one running bastard Clojure instance on Ubuntu Linux. Is there a system that Clojure runs nicely on?

    Lisp believers don’t need to worry about Clojure taking over anything.

    And right now, I’m going back to my Ruby code…yes, I know all you Lisp guys hate it because it isn’t Lisp. It does have this one, small, key feature: it works really well. It installs well. It runs scripts. It doesn’t require a personal relationship with the developer to get running…

    But go ahead and insult it while offering no alternatives. What exactly should I download from the Lisp world, anyway?

    • John says:

      Actually Clojure is pretty easy to install and use. The thing is that it’s Java software, so you just need a few things. First you need a JVM with the java command on your classpath. Then you need the Clojure source or jar file. Then you need to run Java with Clojure on the classpath. If you have extra Clojure/Java libs it makes sense to put them all in the same place and write a short (maybe five line) shell script that builds a classpath string for Clojure and the libraries you wan to use, and starts Java.

      This is all stuff that would be familiar to someone with a bit of Java experience. In fact it’s conceptually simpler than the [download, tar -xvf, ./configure (with options?), make, make install (sudo or not?), is it on my PATH yet?] process that you have to go through to get most other FOSS software installed and running. I’ll agree that clojure.org doesn’t really hold your hand on the Java stuff, which is too bad, because your points are valid and your experience is probably more typical than Clojure people want to admit.

  • xoewp says:

    I think you’re all a bunch of idiots.

    The only reason anyone claims Clojure to be ‘practical’ is because it has the word ‘Java’ in the description. Let me ask you this: have you fucktards actually used it for anything? It really isn’t all that ‘practical’, as the poster above me hints at.

  • Rob Levy says:

    @digitalghost come on man please don’t play dumb. Here is what you do: 1. download Clojure 1.0 (the official release of the language). 2. unpack it, go into the directory and type “ant”.

    And it’s incredibly stable and better than any existing language for concurrency, especially considering how new it is. So that is certainly a step in the right direction. We can compare it to Ruby but we would need to compare it to Ruby when it was only 2 or 3 years old. Anyway Ruby still releases changes that break older Ruby code so you picked a bad example– an old language that has yet to mature or stabilize into more than culty fad phenomenon.

    That said, Common Lisp (sbcl or clisp) implementations do currently work better for scripting than Clojure does. Also performance-wise Common Lisp runs circles around Ruby or any other dynamic/expressive high-level language. However that is no longer the case as you add the need for multiple cores. Clojure has the advance over Common Lisp and certainly over Ruby as fool-proof and expressive concurrency becomes more important. Common Lisp (including Genera from what admittedly little I know about it, having never used it) doesn’t have much to offer in that department, unfortunately.

    There are some features missing (reader macros for example) but I can tolerate that in exchange for better concurrency. As for cube farms, yeah it would be nice to have more Lisp in typical offices, no shame in widespread usage of superior technology if that is possible.

  • truman says:

    1) I just love to use python – more clarity and more powerful
    2) Scala is huge – complexity kills
    3) Clojure is confusing for me – brackets kill
    4) Parallel python is gr8 – can work like scala/clojure
    5) When things can be achieved properly in python why u want other languages – clarity + new speed (unladen swallow) will win

    I expect a module for advanced functional constructs in python

    Above points will touch the needed.

    Cheers.

    • Aravindh Johendran says:

      You have to understand that the brackets offer immense power. Once you grok what the brackets help achieve, you will know what “code is date and data is code” means.

  • polypus says:

    to DigitalGhost & the other obtuse here

    clojure is the nicest lisp i’ve ever used, and i’ve used a few. i’m also a ruby
    hacker, and have been since before rails ever existed, but i’ve switched to
    clojure as my language of choice. why? simple, it is beautifully designed.

    open your minds people.

    • Cosman246 says:

      If you want real beauty, look at a real Lisp.

      Clojure doesn’t count.

      • Bodhilispva says:

        I’ve reached the point in my programming career were I’ve found nothing at all meets my standard of elegance – sadly, not even Symbolics Genera.

        I’ve had to completely turn my back on all “hardware” based programming and retreat to the sanctity of my internal vision.

        I not longer “write” programs in a traditional sense at all. Through deep focus and a body quieted in the lotus position, I am able to orchestrate what I call “lambdas of the mind”. The output cannot be understood by most people; in fact, some might refer to it as “speaking in tongues”.

        At times I reach such a state of grace that the only way an external agency could detect any internal activity is when my bald head turns a bright shade of red. The Greek letter “lambda” that I have tattooed in white on my forehead is then brought into a stark but sublime relief.

  • mwm says:

    Yes, please keep telling people that Clojure is not a real lisp. Then they might give it a chance……

  • Cliff Wells says:

    And yet, somehow, you were practical enough to publish this opinion via Wordpress (and WP undoubtedly being but the tiny visible tip of an entire berg of “worse is better”). I’m wondering which is bitterest: the irony or the seeming futility of it all?

  • Brian says:

    Lisp all the way down? As Clojure in Clojure progresses, increasing amounts of it should be rewritten in Clojure so it would be lisp all the way down to the reflective wrapper at the bottom.

  • [...] is worth noting that nothing like the above could have been written in Clojure, for it lacks user-defined reader macros. [1] This is a “threaded” native-code [...]

  • Yesudeep Mangalapilly says:

    Does it matter that Clojure is not a Lisp? I don’t want Clojure to be C, Lisp, or Java. I want Clojure to be Clojure. If a programming language helps you achieve your goals, by all means, use it! If it doesn’t, what on Earth is stopping you from using another?

    Cheers.

    • Stanislav says:

      Dear Yesudeep,

      Clojure was/is being hyped in some quarters as “the future of Lisp.” This post was a reaction to this.

      Yours,
      -S. Datskovskiy

      • Ashton says:

        Those who hyped it as the “future of lisp” are about as stupid as those who waste time bashing it as “not a lisp.” Then again, I rarely waste my time with people who don’t care if people are more productive or not. If you want to go on an ideological bender, be my guest, I’d rather get things done.

        • Stanislav says:

          Dear Ashton,

          People who only want to “get things done” in engineering — with no care for the long-term effects of their actions — are not unlike environmental polluters.

          You write your program, and it appears to run, and you care not one whit that you are taking a steaming shit of kludgy complexity into the brain of every one of a thousand people who will be forced to read and otherwise interact with your creation in the future.

          Engineering complexity is a form of pollution. The net effect is to make everyone who comes into contact with a system stupider, by increasing the cognitive load required to fully understand it.

          Explorability is today’s casualty of complexity cancer. Tomorrow’s casualty will be the very ability to make a system run at all. Computing as “biology”, and then as outright voodoo. There will be no place there either for you or for me – only for shamans. Is this what you want?

          Yours,
          -Stanislav

  • My beef with Clojure is its non-Javaness. The -main function is only run for compiled Clojure files, not interpreted Clojure scripts.

    No matter what you set your classpath to, (compile ’script) cannot find script.clj, even if it’s in the current directory.

    Ask anyone for help with compiling Clojure code, and they tell you to use Leiningen, Cake, and a host of other tools. I guess (compile) is in NP.

    Multiline shebangs are out. Actually, multiline comment ANYTHING is out, because the only allowed multiline comment is (command f1 f2 f3 …) where f’s are valid Lisp forms.

    The Cube Farm stench has a long trail extending from Java. Obsession with directory hierarchies, JAR files, and complex CLASSPATH concatenations has lead to a system in which writing, compiling, and loading Hello World is impossibly out of reach for newbies.

    • SWI says:

      If you want to interpret it first, you could use (load-file “…”) with “..” standing for the explicit file path which is pretty easy, is it not?

  • We’ve definitely had the conversation “My standard of comparison for any technology will always be everything previously achieved by mankind, rather than what is available on the market today.” before, and I agree completely.

    You’re right, of course. Clojure is not a clean Lisp, and there are a lot of things to dislike about it. On the other hand, I have JVM shwag I need, and the alternative to using Clojure is Scala or Java itself, which is excruciatingly painful.
    I’m a duct tape guy myself. Clojure is the best duct tape I’ve found so far for Java code. The fact that it has become popular is somewhat mind boggling, but it’s good at what it does. Perhaps there is a deep need for duct tape code tools to unify all the different libraries out there.

  • Jason says:

    This was really funny, whether or not it’s meant to be taken seriously (I honestly can’t tell), it was worth the read.

    FWIW, Clojure is attracting a lot of young programmers (like myself) who like the idea of Lisp but are used to (spoiled by?) the usual accoutrements of a modern programming language and community (a high standard for documentation (check out the marginalia project), widespread use within that community of things like github, a decent standard library, a decent package manager (leiningen), etc.).

    I can’t see how giving a new generation a taste of Lisp can be a bad thing. Clojure may not reach the platonic Lisp ideal due to the java underpinnings (although Clojure in Clojure is on the horizon), but it is eminently practical, which counts for much. Look on the bright side!

    *gets off your lawn*

    • Stanislav says:

      Dear Jason,

      > whether or not it’s meant to be taken seriously

      It is quite serious. And my criticisms still stand.

      > but it is eminently practical, which counts for much.

      The impracticality of Common Lisp is more-or-less a thing of the past. I have used it in a number of projects and easily found high-quality libraries which met virtually all of my needs.

      > *gets off your lawn*

      I wrote this particular post after attending a meeting of a Clojure club in Washington, DC. I was almost certainly the youngest person in the room.

      Yours,
      -Stanislav

      • jhuni says:

        > The impracticality of Common Lisp is more-or-less a thing of the past. I have used it in a number of projects and easily found high-quality libraries which met virtually all of my needs.

        Why were you using the Common Lisp “abomination” on a number of projects and not your beloved Mathematica?

  • jhuni says:

    I just realised that you support Mathematica. You provide a link to the Mathematica troll Xah Lee in the sidebar, in this very post you claim that Mathematica can be used as a standard of comparison to other software on the market, you claimed on hacker news that “Mathematica is the only system you find tolerable”, etc. You even recommended that I personally try Mathematica, which is effectively an advertisement for this piece of expensive proprietary software. I have been following this blog for a quite a while now and this is the first time I have become disappointed as a result.

    > It is the most explicit to date abandonment of the age-old Lispers’ Dream, “Lisp All The Way Down.”

    No its not. The most explicit abandonment of the age-old Lispers’ Dream of “Lisp All The Way Down” is proprietary software. Mathematica is proprietary software which is a part of this explicit abandonment, so you are an utter hypocrite for praising Mathematica well denouncing Clojure for this.

    > Aficionados of real Lisps, such as myself, will keep hoping, dreaming, and working on systems which do not betray the original virtues of the language.

    You aren’t an “aficionados of real Lisps.” You claim that Clojure and Common Lisp are “abominations” well advertising Mathematica to people. You claimed that Mathematica is the “only programming environment I find tolerable” despite the fact that there were thousands of far superior Lisp alternatives available at the time. You denounce these real Lisps well praising this piece of expensive proprietary crapware instead. Unlike you, I am an aficionados of real Lisps because I support both Common Lisp and Clojure as opposed to proprietary crapware like Mathematica.

    > It promotes – no, mandates – the use of undigestable foreign matter in Lisp code: primitives on which you cannot pop the hood to reveal intelligible innards.

    Actually you can pop under the hood of any Clojure primitive to reveal its intelligible innards. Just open up a Clojure REPL and try (source cons), (source eval), (source apply), etc. This works for everything in clojure/core. Furthermore, you can even examine the source of Java since it is free software now as well. This feature is explicitly denied from Mathematica users.

    > The Clojure user who is missing some routine or other will run crying to Java for help

    I will personally take Java and Eclispe over Mathematica anyday if for no other reason then that they are free software. I highly doubt that Mathematica allows you to be significantly more productive then Eclispe anyways. Eclispe provides you with “integrated documentation with worked examples for practically every language feature”, special plugins for handling “vector/bitmap graphics”, “audio”, etc and most of the things you praised Mathematica for. Furthermore, it provides you with autocomplete and easy access to thousands of Java libraries.

    That is to say nothing of the improvements over Java provided by Clojure or the improvements over Eclispe provided by Lisp IDEs like the one I am personally developing using Clojure and Piccolo2D. In my IDE you will be able to use the zooming user interface provided by Piccolo2D and the source function I previously mentioned in order to zoom into any Clojure primitive and examine and edit its contents in place.

    • Stanislav says:

      Dear jhuni,

      I used Mathematica for a while before I got good with Common Lisp. My employer at the time willingly paid for it. I liked it because it had a true REPL; the best I had used up to that date. I simply hate writing code any other way. When you cannot create your program out of tiny, perfect pieces tested individually, in real time, and on a whim, the OODA loop is simply too long for my tastes.

      However, I’ve barely touched Mathematica for more than two years now. Yet there are still things to be learned from it. You have used languages with true REPLs – say, Common Lisp (or even Clojure) with SLIME. Now picture graphics, audio, etc. as first-class objects in the REPL – ones which you can cut&paste, transform into lists of meaningful numeric values on a whim – and back, etc.

      But of course Mathematica is expensive, dog-slow, and opaque. I ditched it and quit asking my lab to renew the support contract when I found a critical bug in one of the “helpful” built-in computational biology routines – that Wolfram refused to fix. The bug is still there.

      Only morons refuse to learn from a politically-hated enemy. Have you any idea what Symbolics Lisp Machines once cost? Of how tyrannical the license terms were? None of it changes the fact that they were a superior technology. Or that we are now stuck with the idiot Unix and counter-Unix world as a result of the hatred and rebellion.

      Don’t be a moron. Learn from every system.

      Yours,
      -Stanislav

      • jhuni says:

        > Now picture graphics, audio, etc. as first-class objects in the REPL – ones which you can cut&paste, transform into lists of meaningful numeric values on a whim – and back, etc.

        The idea of S-expressions that have a one to one correspondence with visual meta-expressions is an ancient Lisp idea, as is the read eval print loop (REPL). The only reason you “learned from it” is that you didn’t realize that ideas like interactive visual meta-expressions have been with Lisp for a long time. For example, the Racket programming language has S-expressions that have a one to one correspondence with graphical meta-expressions:


        (rectangle 10 20)
        (circle 10)

        Most developers today are familiar with first-class graphics through the use of the Lisp ripoff known as “XML.” The SVG standard provides graphics that have a one-to-one correspondence with XML and formats like MusicXML provide a one-to-one correspondence between XML and audio. Consider the following SVG code as an example:


        (rect (:width 100) (:height 100))
        (circle (:cx 10) (:cy 10) (:r 10))

        Chris Granger’s new IDE Light Table encodes SVG graphics and HTML code in S-expressions and it actively updates a graphical meta-expression corresponding to these S-expressions. The idea of interactive visual meta-expressions has been present in the Lisp community for several decades. I am not familiar with any features provided by Mathematica that haven’t been available in Lisp for decades.

        > Only morons refuse to learn from a politically-hated enemy.

        Stephen Wolfram is an elitist prick who ripped off ideas from Lisp and Macsyma. He produced no new innovations and yet he went to claim that he is “widely regarded as the most important innovator in scientific and technical computing today.” Wolfram has displayed a new kind of arrogance so he is hated for good reason.

        Only a moron would study a cheap ripoff like Mathematica rather then the superior original technology (Lisp). When you first told me to “try Mathematica” I didn’t think you were serious, it has no ideas that Lispers aren’t already familiar with.

        • Stanislav says:

          Dear jhuni,

          > ideas like interactive visual meta-expressions have been with Lisp for a long time.

          So, down to business: where is the working Lisp-based graphical REPL? I would dearly love to try it.

          > (rectangle 10 20) (circle 10)

          So, in which modern Lisp can I drag the output resulting from these expressions back into the REPL and instantly see it as an S-expression?

          Wolfram is indeed hated for a good reason. But Mathematica’s UI was written by Theodore Gray.

          And as far as I know, it is unique – in a number of important ways. And worth studying, even if not a mere Wolfram but Hitler himself had written it.

          > it has no ideas that Lispers aren’t already familiar with.

          This is simply wrong. Seriously, get the demo version and play with it for a day. It costs nothing.

          I don’t advocate Mathematica as a basis for building anything. Everything I had ever written in it, I later had to re-write. It is a technological dead-end. But it contains ideas that are worth learning from, mainly because Wolfram (like Edison, another sociopathic taskmaster masquerading as an inventor) had an aptitude for hiring clever people and letting them experiment freely.

          Don’t make the mistake of believing that the things you have never seen and refuse to experience count for nothing.

          Yours,
          -Stanislav

  • [...] Clojure as it’s future is a new low in the community. Another lisper put it so bluntly : “Clojure is the gutted and zombie-reanimated corpse of a dream.” If anything, Clojure is hopefully the future of the JVM. It is definitely a step up the language [...]

Leave a Reply

XHTML: You can use these tags: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong> <pre lang="" line="" escaped="" highlight="">