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.

114 Responses to “Thumbs Down for Clojure”

  • [...] Clojure introduces new problems(ok ‘challenges’ if you will) having discarded enough of the last half-century of Lisp progress. Sure, Common Lisp has it’s problems but hailing 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.” [...]

  • Kevin says:

    Posts like these are the reason I was never interested in being a part of the CL community. If you want this dream to come true, start playing the fucking game.

    • Stanislav says:

      Dear Kevin,

      And which game would that be? The one where people compete to see who can write a more pathetic cheap imitation of Common Lisp?

      Yours,
      -Stanislav

      • Daniel says:

        No, it’s the one where you make Common Lisp libraries that solve real problems.

        Common Lisp is amazing. I too wish it were better, but most of its libraries are undocumented, half-implemented hacks that take more effort to use than the imperative counterparts that they are mimicking.

        I can’t build usable software in CL in anywhere near as short a time as I can with Java, let alone Clojure, and that may speak little for my programming skills, but we can’t keep point at twenty years ago saying, “Look, Lisp is better” when it hasn’t actually done anything within the last five.

        • Stanislav says:

          Dear Daniel,

          > most of its libraries are undocumented, half-implemented hacks…

          This has not been my experience. Not in the last five years, anyway.

          > I can’t build usable software in CL in anywhere near as short a time as I can with Java

          Common Lisp is a Stradivari violin, not a kazoo. It simply isn’t for you – you have just admitted as much. Go learn a different respectable trade, where you might be able to fully appreciate high-quality professional tools.

          > [Lisp] hasn’t actually done anything within the last five.

          You know, your problems might stem from the fact that programming languages are not actually alive, and cannot do anything on their own.

          If you want to know why Lisp doesn’t win around you, find a mirror.

          Yours,
          -Stanislav

          • Luc Prefontaine says:

            Stanilas,

            I do not know your age but I can tell that you live in the past. Symbolics Lisp machines were still
            around when I started to work (after I spent a few years on the school benches).
            They eventually disappeared, superseeded by ( I agree 100%) “low” quality solutions,
            sorry but that’s a fact of life.

            I tried several times to get a product to market using Lisp in the last 10 years, being fed up of
            Java and alikes.
            The library issue in Common Lisp especially has been a pain in the ass during all those years, facing
            either non existent non existent librarieis or in the wrong “dialect”.

            There was always mising pieces, fixing all of these within a product delivery cycle just
            shut the business case down.

            Now we have a product up in Clojure running happily since Jan. 2009. It solves a complex
            problem in a minimum code base. Libraries ? Java has plenty and investing to recode this low level
            stuff is not worth it. Using them from Clojure is a charm. We have a one to ten code line ratio
            compared to other solutions and the remaining code is much more powerful than it’s Java or
            similar equivalents.

            We can focus on the important features that boosts the product value up and leave the mundane
            stuff out of the task grid.

            Over the last 30 years, I focussed on delivering working solutions using a variety of languages and
            solutions. I got my frustration out this way and it’s been paying off through all these years.

            You seem to be stuck in some purgatory from what I can see in your posts.
            Maybe you should change your assumptions instead of sticking to fossilized tools.

            Jurassic Park is science-fiction…

            Luc P.

            • Stanislav says:

              Dear Luc P.,

              > I do not know your age but I can tell that you live in the past. Symbolics Lisp machines were still around when I started to work

              I’m 29. My Lisp machine is second-hand.

              > They eventually disappeared, superseeded by ( I agree 100%) “low” quality solutions, sorry but that’s a fact of life.

              Fuck your so-called “facts of life.” Superior mind-amplifying tools existed and will exist again.

              > The library issue in Common Lisp especially has been a pain in the ass during all those years, facing either non existent non existent librarieis or in the wrong “dialect”. There was always mising pieces, fixing all of these within a product delivery cycle just shut the business case down.

              Yiddish saying: “the bad dancer is hindered by his own arse.”

              “If you want to know why Lisp doesn’t win around you, find a mirror.”

              > Now we have a product up in Clojure running happily since Jan. 2009.

              Good for you.

              > You seem to be stuck in some purgatory from what I can see in your posts. Maybe you should change your assumptions instead of sticking to fossilized tools.

              Common Lisp is paying for my dinner and the roof over my head. And has been for a while. Go shove your assumptions into the place where they belong. It is your tools – the quasi-static, batch mode (anything other than Common Lisp + SLIME, or possibly Mathematica) languages which are really fossils.

              Yours,
              -Stanislav

              • Luc Prefontaine says:

                29 years old ? That explains a lot, weak notion of history => bad perception of future trends.

                Funny that you are crazy about a language that I was using while you were crawling around
                wearing diapers… and I mean really crazy :)

                You are fossilized in time around the end if the 50s and you were not even born ?
                Bad karma ? Reincarnation hell ?

                Wether you like it, Clojure is a Lisp and offers much more than Lisp used to offer in the past.

                I doubt you will ever undestand that however, your horizon is the same as a fly,
                three feet wide and you seem to be unwilling to enlarge it.

                Have a nice life in your mental dungeon…

                • Stanislav says:

                  Dear Luc Prefontaine,

                  > 29 years old ? That explains a lot, weak notion of history => bad perception of future trends.

                  If I tell you that I have studied (and used under emulation, when available) nearly every major historic Lisp system, would it make any difference?
                  You have already decided to prepare an insult, and you wished to know my age so that you could decide whether to call me a doddering senile vegetable or an ignorant child.

                  My impression is that you came better-prepared for the “doddering vegetable” scenario. My apologies, then, for catching you with your pants down.

                  As for trends, why should I be concerned with them? The fact that you mention trends at all is rather telling. It would appear that the world as you see it contains no sentient beings able to go off on their own paths, but only ants who follow the pheromone trails of other ants around in a circle forever. That is the world of YCombinator types and other trendoids: an idiotic fashionista hell.

                  > Funny that you are crazy about a language that I was using while you were crawling around wearing diapers… and I mean really crazy :)

                  The dishonest implication here is that you moved on to something better, rather than accepting an inferior substitute for the truly-interactive computer which once existed, and then lying to yourself (and others) about it. Take heart, for you are in good company. See, for instance, this great luminary’s cowardly surrender to cultural decay:

                  “6.001 had been conceived to teach engineers how to take small parts that they understood entirely and use simple techniques to compose them into larger things that do what you want. But programming now isn’t so much like that, said Sussman. Nowadays you muck around with incomprehensible or nonexistent man pages for software you don’t know who wrote. You have to do basic science on your libraries to see how they work, trying out different inputs and seeing how the code reacts. This is a fundamentally different job, and it needed a different course.”

                  Or better yet: Dan Weinreb (one of the original designers of the MIT and later Symbolics Lisp machines), in his old age penned this masterpiece of idiocy about the OLPC being “the next Lisp machine.” I can’t really blame Weinreb for his wishful thinking: his life’s work had been destroyed by morons. Even having become a millionaire at ITA cannot compensate him for this. But what is your excuse?

                  > You are fossilized in time around the end if the 50s and you were not even born ? Bad karma ? Reincarnation hell ?

                  It is the users of batch-processing (edit, compile, pray, debug cycle) programming systems who are fossilized. Interactive, fast computers now exist, and virtually every programmer seems to remain unaware of this.

                  > W[h]ether you like it, Clojure is a Lisp and offers much more than Lisp used to offer in the past.

                  Which Lisp, and which past? Have you ever seriously used an MIT, Symbolics, or TI Lisp machine? Xerox Interlisp? Current SBCL with SLIME?

                  > I doubt you will ever unde[r]stand that however, your horizon is the same as a fly, three feet wide and you seem to be unwilling to enlarge it.

                  If you and the other Clojure enthusiasts were content with narrowing your own mental horizons (accepting a Lisp which barfs Java stack traces, encourages the use of Java’s static data structures, introduces questionable pseudo-innovations like immutable data, etc.) I would care not a whit. You will not find a “Thumbs Down for Python” essay in this blog, because Python users make no attempt to peddle their crock of shit as “the future of Lisp.” I have no quarrel with users of Python, Ruby, Dylan, and other shoddy “infix Lisps.” Because they are honest.

                  It is the lying of Clojure users which upsets me, and their deliberate attempts to rewrite history, to make people forget that truly-interactive, advanced Lisp systems once existed.

                  I understand making technological compromises. I understand driving a “junkyard wars” vehicle when a Toyota cannot be had for whatever reason. But don’t lie and call your rattling heap of junk “a modern Toyota.”

                  Do you wonder why this thread is still active after three years? Why it is often found among the top Google hits for the word “Clojure” ? It is because everything I said here is true, and the Clojure enthusiasts know it. The truth hurts, doesn’t it? You know, I don’t actually care what kind of lies you have to tell yourself to stay sane. But don’t lie to children and other neophytes and tell them that Clojure is a “modern Lisp.” It won’t work, if only because I intend to personally see to it that everyone finds out just what a modern Lisp looks like.

                  > Have a nice life in your mental dungeon…

                  I will have a nice life in my mental palace.

                  And Clojure is still a turd, though you call it sausage and eat with relish.

                  Yours,
                  -Stanislav

                  • Cosman246 says:

                    This is, indeed, the heart of the issue–the dogma spreads to represent communities they are not a part of

                    On a similar note; I am currently working on a specification for a future Lisp dialect, which, if I am worthy, I hope to eventually implement (and I am willing to take criticism). I would like to share it with you, Stanislav, but I do not know your email address. Could you send it to the email under my name here?

  • Ben Gillies says:

    “No true Lisp would ever be built on top of something else.”

    “No real Lisper would ever use something so tragically impure.”

    Reminds me of this.

  • Luc prefontaine says:

    Your last post shows how little you know about Clojure.

    It’s dynamic, we rarely restart a JVM when coding/testing. No incessant redeploys…
    There is no edit, compile,debug,… cycle. The fact that the Clojure is compiled on the fly
    to byte code has no impact on how you work.

    Our app loads code on the fly according to the current configuration and it’s all evaled on the fly.

    So far for your assertion that Clojure is a static world. If you thunk down to Java, of course
    you end up with the Java limitations. They have nothing to do with Clojure. If you avoid coding
    in Java you avoid these issues. Using Java libraries from Clojure is not a problem most of the time except
    a few that have been ill defined from the start.

    Debugging has improved a lot either through IDE standard JVM debuggers or more Clojure oriented ones.

    Stack traces can be filtered out so they look a bit more friendly. I agree some improvement
    would be welcomed here (albeit some Clojure libs exists to prune these a bit)
    but after a while you get familiar enough to find the root of the problem quickly enough.

    As of persistent immutable structures, it’s obvious that you did not code enough multithreaded
    applications to understand the value of having mostly immutable data in your code.

    This last post from you indicates clearly that your horizon is limited and you are allergic
    to new ideas and cannot bring facts and rationale to your statements.

    It’s fine to criticize if you can bring some rational reasonning at the table.

    Right now you look more to me as a Taliban than nothing else. Dogma, dogma, dogman and no
    inclination for facts.

    I stop here, I have other things to carry this week and I think your need to slack your horse
    blinders a bit before any significant discussion can happen.

    Luc P.

    • Stanislav says:

      Dear Luc prefontaine,

      > Your last post shows how little you know about Clojure.

      Your arguments show how little experience (or memory thereof) you have with genuine, interactive, conceptually-consistent Lisp systems.

      > It’s dynamic, we rarely restart a JVM when coding/testing. No incessant redeploys… There is no edit, compile,debug,… cycle. The fact that the Clojure is compiled on the fly to byte code has no impact on how you work.

      Take ten minutes to watch this video of Symbolics Genera. That is what actual dynamicity looks like. But if you still want to abuse the word and apply it to environments where one must edit an ASCII text file and feed it to a compiler after each change is made, go right ahead. Perhaps you can fool someone else, but you won’t fool me.

      > Our app loads code on the fly according to the current configuration and it’s all evaled on the fly.

      > So far for your assertion that Clojure is a static world. If you thunk down to Java, of course you end up with the Java limitations. They have nothing to do with Clojure. If you avoid coding in Java you avoid these issues. Using Java libraries from Clojure is not a problem most of the time except a few that have been ill defined from the start.

      It is quite impossible to work in Clojure without having any contact with Java and the JVM. You know this well. Clojure barfs Java stack traces. Clojure errors produce no meaningful Clojure-related information! Clojure does not even have a condition and restart system. And, the way it is designed, it appears that it is fundamentally incapable of being retrofitted with such systems.

      > Debugging has improved a lot either through IDE standard JVM debuggers or more Clojure oriented ones.

      Let me know when a Clojure system which halts on an error does something other than crash and spew JVM crud at me.

      > Stack traces can be filtered out so they look a bit more friendly. I agree some improvement would be welcomed here (albeit some Clojure libs exists to prune these a bit) but after a while you get familiar enough to find the root of the problem quickly enough.

      You are now comparing “filtered” Java stack traces to Common Lisp’s condition system? Fine… I will dine on chocolate ice cream while you eat “filtered” liquid shit.

      > As of persistent immutable structures, it’s obvious that you did not code enough multithreaded applications to understand the value of having mostly immutable data in your code.

      Having spent some years working on massively-parallel scientific computation projects, I am finding this conversation hilariously funny.

      > This last post from you indicates clearly that your horizon is limited and you are allergic to new ideas and cannot bring facts and rationale to your statements.

      Pray tell, just what are the “new” ideas in Clojure? The idea of setting up an ersatz Lisp on top of the JVM is not the least bit new. Neither is immutable data.

      > It’s fine to criticize if you can bring some rational reasonning at the table.

      Neither you nor the other Clojure enthusiasts appear to be interested in rational discussion. This is because a rational analysis of Clojure (vs. Common Lisp on an x86 PC, not even talking about ZetaLisp or InterLisp) would leave the Clojure users crying and hating their lives within five minutes.

      > Right now you look more to me as a Taliban than nothing else. Dogma, dogma, dogman and no inclination for facts.

      Look in the mirror.

      > I stop here, I have other things to carry this week and I think your need to slack your horse blinders a bit before any significant discussion can happen.

      Exactly why are you here, on this site? There is such a variety of other things to read.

      Yours,
      -Stanislav

  • Lydia says:

    Bonsoir Stanislav !

    Permettez-moi d’employer le français, je parle très mal l’anglais.
    Votre position m’intéresse beaucoup, vous semblez très bien connaître le sujet !

    Je recherche un vrai bon Lisp, Mais, plus je cherche et moins je sais vers quel Lisp me diriger ?

    Pouvez-vous me conseiller et m’indiquer une adresse de téléchargement d’un vrai bon Lisp ?

    Merci pour votre réponse.

    Lydia

  • ilia says:

    All of the arguments above have basically been idealism vs pragmatism.

    Yes lisp machines are epic, no one disagrees. However clojure makes more sense in the context of legacy software. No matter how shitty it is, we have a decade’s worth of java libs which can’t just be thrown away. For many java guys clojure is a godsent because it’s a way out.

    Your position seems to be “my lisp or no lisp” which is quite childish.

    • Stanislav says:

      Dear ilia,

      > No matter how shitty it is, we have a decade’s worth of java libs which can’t just be thrown away.

      We also have four decades of COBOL code which can’t just be thrown away. When do we get COBOLISP, the marvelous Lisp of the Future built on top of and freely intermixed with COBOL? I’m waiting eagerly.

      Why no hype over Armed Bear Common Lisp, which predates Clojure and interoperates with Java in a similar way? The answer is simple: ABCL had no hype-master to push it, and thus no hipster community to mindlessly take it up.

      > Your position seems to be “my lisp or no lisp” which is quite childish.

      My position is that lying is wrong, and that a turd is still a turd even when you call it sausage and eat with relish. Clojure is being pushed by its enthusiasts as “the new, modern Lisp,” which is a bold-faced lie. See this.

      Yours,
      -Stanislav

      • ilia says:

        > We also have four decades of COBOL code which can’t just be thrown away. When do we get COBOLISP, the marvelous Lisp of the Future built on top of and freely intermixed with COBOL? I’m waiting eagerly.

        Lets imagine a cobolisp *shrug* had existed and recieved as much attention and acceptance as clojure is currently getting (work with me here). Functional programming/lisp might have been mainstream by now. No matter how much I cringe at the idea of such a disgusting crossbreed, it would have been worth it. I hate memes, but I think this one conveys my opinion perfectly http://axisofeval.blogspot.ca/2012/07/when-somebody-says-but-clojure-will.html

        Either way, COBOL has been around much longer than it should have due to legacy codebases. It’s a problem that didn’t get solved and I see clojure as a pretty good attempt at tackling the identical situation that currently exists with java.

        > Why no hype over Armed Bear Common Lisp, which predates Clojure and interoperates with Java in a similar way? The answer is simple: ABCL had no hype-master to push it, and thus no hipster community to mindlessly take it up.

        I’ll be honest and say I didn’t know about ABCL. But I think ‘hype-masters’ (or evangelists as some like to call them) are pretty essential for any new language.

        I do partially agree with you on this one, but at the same time I’d rather have fad obsessed hipsters pick up a lisp (no matter how big of a ‘turd’) than the next imperrative counterpart. Crappy lisp is better than no lisp and if you disagree we’re back at idealism vs pragmatism.

        > My position is that lying is wrong, and that a turd is still a turd even when you call it sausage and eat with relish. Clojure is being pushed by its enthusiasts as “the new, modern Lisp,” which is a bold-faced lie. See this.

        There’s a big difference between lying and having a different opinion. But I don’t really see the problem, I don’t hear people claiming that it’s a “new BETTER lisp”. Modern is a very subjective and ambiguos term.

        I did initially share some of your feelings toward clojure. It felt fake, as if I was using some type of nasty hack. But I’ve come to like it very much.

        • Stanislav says:

          Dear ilia,

          > Functional programming/lisp might have been mainstream by now.

          Why do you assume that I believe this to be a positive thing? It isn’t, in my view. Professional tools, placed into the hands of idiots, inevitably degenerate.

          > Crappy lisp is better than no lisp

          This is where we disagree. When an inferior substitute for a given technology is passed off as the real thing long enough, the genuine tech is slowly forgotten. It gets, if you will, “un-invented.” I see no reason to cheer this process on with regards to Lisp.

          Yours,
          -Stanislav

  • Nick says:

    I have to say, although I like Clojure, you have a very good retort to Luc’s rather moronic criticism. I can’t stand age-based criticism; it’s a weak form of arguing.

    • Luc Prefontaine says:

      Hi Nick,

      it’s not about age, it’s about experience.

      I was using Emacs and Lisp on DEC-10/20s while Stanislav was not even crawling around wearing
      a diaper.

      I went through several evolutions in the software industry. I think I know a bit what changed,
      what failed and what succeeded. I coded complex systems during all these years using a dozen
      different languages and several platforms. I still code actively everyday.
      I worked with Cobol. Fortran, Pascal, C/C++, several assemblers, …
      Today, I work with linux, Ruby, Clojure and Java (less and less btwy).

      I am an implementer, I appreciate tools for their net worth. Theories are great and necessary
      but ultimately, implementations are the only metric by which we can judge merits.

      Lisp machines are dead, Lisp has not been catching up on the market (which I regret),
      being nostalgic about Lisp’s “perfection” is not getting the software industry anywhere and
      does not help address the next evolution step.

      If Clojure is an imperfect implementation according to some theorists but still gets people on board
      and solve real world problems more efficienctly than other main stream tools then why not ?

      Clojure is a practical answer to real problems and presents an affordable learning curve to
      this bunch of people that Stanislav seems to qualify as morons. They will eventually be exposed
      to concepts that are now alien to them and it may save some from hell. The fact that Clojure
      blends such concepts in a smooth way makes them much more worthy than when these features are
      singled out. I never said that Clojure implemented new concepts, it’s the recipe that makes this
      interesting from an implementor’s point of view.

      I did not want to critic based on Stanislav’s age, I wanted to emphasized its lack of various experiences.
      I consider Clojure a significant step based on practical experiences not based on some
      religious fanatism.

      With “aging” comes questions like how do you maintain your edge, your interest and your efficiency ?
      How do you make this time left worth more than the time behind you ?
      The choice of tools becomes more important as you age. Lisp could be great but it’s not an option
      for an implementor these days except in rare circumstances.

      Live long enough, try different tools in big projects (essential) and do some introspection along the
      way. Eventually you will understand that reality always catches up.

      Luc P.

  • [...] Loper is not happy: 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. Source [...]

  • https://groups.google.com/forum/?fromgroups=#!topic/clojure/BJQ3l6dL4V8

    Not to hate on Clojure (as I’m trying to learn it) but this struct me as odd when I read it. As a hosted language some “unspecified” behavior depends on the host. So in the JVM (+ 1 “er”) and (+ “we” “er”) returns errors but in Clojurescript it returns “1er” and “weer”. And what surprised me the most was the position of Rich Hickey:

    “(+ “we” “er”) is a user error.

    We rely on the runtime type system of the host to efficiently detect
    type errors. ( …) Nowhere does Clojure promise that all user errors will become
    exceptions, and it is a constant balancing act to add more checks
    without compromising the performance of correct programs.”

    Just my 2c.

  • tim says:

    you’re post is high on google, because it is interesting and controversial. I was laughing as i read this thread. thanks for entertaining me.

    I do not have much experience with lisps (yeah, i read some clojure things, still trying to set that up. might help save time in the long run). I do have some with mathematica. It is a computer algebra package. it may be a programming language, technically. but If mathematica is a programming language, then superlogo is too. superlogo is also a kids’ toy ;)

    mathematica is a very useful tool for mathematicians. and it’s a great program. finally something that allows you to enter a formula, view it and evaluate it, solve it, whatever.

    if you like it so much and prefer it over common lisp, maybe you could find work in it. every student knows mathematicians hate to do computer work . they haven’t even discovered the benefits of microsoft powerpoint yet. I guess they could use an assistant.

  • Michael Ellis says:

    Wow. This is absolutely hysterical. Sorry dude, Clojure won. Get over it.

    • Stanislav says:

      Dear Michael Ellis,

      Actually, PL/I won. That is to say, it is more widely used than Clojure, and I personally know of people earning six-figure sums (U.S. dollars) solely because they are willing to program in it.

      But if you were speaking of the idiot trendoid crowd, yes, Clojure “won” there. That’s what prompted this article. Now kindly return to your heathen-pit.

      Yours,
      -Stanislav

  • Mike B says:

    Well, I read this post a year (or more) ago, and now I disagree with it even more.

    First of all, the fact that Clojure compiles to JVM bytecode isn’t unlike how every language implementation produces some sort of bytecode or compiles down to machine code. Second, while Java may suck, the JVM isn’t bad – it’s fast, good for concurrency, reliable, and runs everywhere. OpenJDK also has the patronage of Oracle, IBM, Red Hat, Apple, SAP, and others…

    Also, I’m just looking at the tools available to Clojure programmers. Emacs with Swank, Light Table, Catnip – all interactive REPLs that enable you to edit code on the fly. I use Catnip myself – it’s open-source, dead simple to setup (unlike Emacs), and just works. Leiningen is also easily the best build tools I’ve ever encountered – it sets up a project, has a bunch of useful commands, REPLs, and it’s dead simple to package your app into a single, self-contained .jar file.

    While Clojure isn’t as idyllic as the Lisp machines we love to reminisce about, it offers all the same practical benefits, and more. We have a language with which we can target literally any platform. The few places you can’t use the JVM you certainly can use ClojureScript, which compiles to JS. And right now someone is writing a C implementation of Clojure.

    Fact is, people are actually building stuff with Clojure. I can make desktop apps with Swing, games for the desktop or Android (there’s actually a Clojure game published on the Google Play store, and it’s very professional and fun!), or I can make web apps with Pedestal (which also uses a Datomic database, which itself is a product of Rich Hickey – Clojure’s creator). Financial institutions and hedge funds use Clojure, and a diverse range of startups and individuals. Thankfully, it also seems like most of the hipsters moved on to Nodejs.

    By the way, I wouldn’t mind if a ‘real’ Lisp became the de-facto standard and your Loper OS took off. That would be fantastic. But right now, I need to eat, and program to get things done, and Clojure simply has a more compelling set of features and tools.

    • Jakub L says:

      Evaluating (+ 2 “e”) pukes some shit about casting to java.lang.Integer and clojure.lang.Numbers.add. It bukakkes you with Java errors that have no meaning and relation to the code you actually wrote.

      No matter how practical or accepted, the language is still shit. And it’s dangerous, since, with each passing blogger touting this monstrosity as the future of LISP, it actually will become the future of LISP. A bleak future, a future where LISP means Clojure and the marvel and beauty of true LISP environments is finally irreversibly forgotten.

  • math says:

    More important i think is why everyone is hard to start programing languages its their crazy style.

    Imagine (n = 1) in math 12 school years young peoples life it was a way of thinking.

    In programing language it somehow became stupid (= n 1) wtf? in math it will be error! how you want teach kids of programing then language dont care of even basic math rules! and way of thinking? to learn another 12 years??

  • Slevin says:

    You must really love lisp, judging from your well-written responses. I however am but a budding Lisper. I can’t say whether Clojure deserves to be called a Lisp(your reasons, however passionately presented don’t convince me enough). If there’s one thing that would make me give Clojure, it would be, like you said, the Java stacktraces. It makes Clojure look half-baked and plain unintelligent. Why doesn’t it have it’s own error messages. When I look at those error messages, I can’t but think that the Clojure compiler translated the the code to java, wrote a .java file than ran the equivalent of system(”javac file.java”);
    Regarding to your rant, I thought Lisp had a compiler that works pretty much like any other language’s, i.e in batch mode?

    • Stanislav says:

      Dear Slevin,

      Re: Clojure: Don’t take my word for it; see for yourself how it is implemented. (As a thin layer on top of the JVM. Although several people have attempted saner stand-alone implementations, these are still stuck with the overall inescapable lameness of the language features, such as immutable data.)

      Re: compiler: ANSI Common Lisp, interestingly, does not specify the exact behavior of the compiler. However, in a well-designed implementation (e.g. SBCL, my favorite) the compiler is present at runtime, and input to ‘eval’ actually gets compiled prior to execution.

      Yours,
      -Stanislav

  • Drew says:

    I get that you wouldn’t want to muck around with Java while you’re trying to use Lisp, but if you’re using Common Lisp then don’t you still have to mess with FFI code and sometimes even the code you’re using the FFI with? Is it just less common?

  • Robert Taytlor says:

    Stanislav, amazing post. Amazing responses to a wonderous amount of idiots.

    It is such a welcome breath of fresh air to see someone put their foot down and call mediocrity for what it is … enabling of nothing more than more mediocrity.

    We too have new products based on Common Lisp and are quickly moving to Common Lisp being our defacto standard.

    Hear hear.

  • Chris Z says:

    I’m a clojure dev and I came back to this post after a year and I still find it quite refreshing. It makes me think about what else is out there. I came to lisp through clojure and I’m addicted – I’m looking at chicken and picolisp and loving what they do. Common Lisp still scares the crap out of me so I may take a look at that when I have more experience. I completely agree with many points in the post because those are shortcomings that could have potential solutions. my question is: is clojure fixable and how would you go about it?

    • Why does Common Lisp scare you? Its a big language, but other than that it is quite forgiving.

      No, Clojure is not fixable. The whole design is bad, from bottom to top. When I first watched a talk by Hickey I liked some of his views. Since I work with Clojure I am quite angry with him. Every single design decision in Clojure is wrong. The good parts are those where Hickey was lazy and just copied standard Lisp behaviour.

      I believe Hickey is a master troll and messed with us BIG TIME. Why? I don’t know.

  • Hey, what do you think about red a dialect of rebol(similar to LISP)…

    http://www.red-lang.org/ (read the contributions section)

    The idea is to be red all the way down, what do you think?

    • Stanislav says:

      Dear Jacob Goodson,

      ‘All the way down?’ Appears to mention ‘Android’…

      Yours,
      -Stanislav

      • Jacob Goodson says:

        It mentions being useable on the android, you should not dismiss it because you saw the word android. It will use a bridge to work with the dalvik, other than that you don’t need a jvm or eclipse to work with android at all while programming in red.

  • Quizdr says:

    While I don’t entirely disagree with the notion of purity that you seek in a lisp language, I do want to point out that I have never written any Java code, and this continues to be the case, even after using clojure now for several months to create some pretty fun software. So the notion that you must somehow incorporate java into clojure code is simply incorrect, you can do a tremendous amount with the powerful library built into clojure, that is written in clojure itself. No one should be turned away from clojure simply because of the notion they must also write or use Java code. Just wanted to point that out, as readers of this page should not be misled on that regard.

    All other issues aside, one particularly useful feature of clojure is its default immutability, which I do believe natively encourages better program structure, reduces bugs, and makes the language easier to learn.

    • Jacob Goodson says:

      Well, I believe using Java is not really the problem, the problem is the fact that if you run into an error sometimes the program crashes with page loads of stack traces. The errors in clojure are contrasted to CL which are much easier to deal with since CL has a much better error handling systems.

  • Andreas says:

    Haha, this is hilarious! I always thought the Lisp fundamentalism was a myth, but now I know better. I hope the Clojure community will keep offend you with awesome software.

    • Stanislav says:

      Dear Andreas,

      I keep hoping to be ‘offended with awesome software,’ but instead I must settle for being bored with the tediously buggy variety.

      Does your runtime still barf JVM stack traces?

      Yours,
      -Stanislav

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="">