1. 22
  1.  

  2. 14

    Psychologically, using REPL this way improves the flow, the complete immersion in one’s activity without interruption. No wonder Clojure programmers are found to the happiest: a mental state of flow improves well-being and life satisfaction.

    I clicked the link:

    Clojure developers are the happiest - When Hermann looked at the use of words indicating happiness (e.g., “awesome,” “cool,” “fun”), comments made to posts in the Clojure subreddit came out on top.

    What.

    1. 3

      I did the same and I read the title of that article

      Clojure developers are the happiest developers

      And then the conclusion

      Anyway, this analysis, obivously, doesn’t really prove that Clojure developers are the happiest…

      Oy vey… the disclaimer and conclusion were fair but the title was quite the bait!

      1. 3

        It’s the modern scraping of Usenet for the word “pointer”. /s

        More serious, the original author did put a disclaimer that it wasn’t hard science and just a fun project.

        https://github.com/Dobiasd/programming-language-subreddits-and-their-choice-of-words#disclaimer

        1. 10

          Yeah, the linked project sounds like a fun thing, I’m just piffed that the OP cited it unironically. Makes me doubt their objectivity in general, y’know?

          Same with this:

          Clojure is one of the only four languages where language choices is statistically significantly correlated with software quality in this large scale study. The other two “good” languages are found to be Haskell and Ruby, the one “bad” language is C++, while Clojure has the highest statistical significance number on the “good” side.

          Which is a shockingly bad misinterpretation of the paper. One of the authors of the paper commented as much:

          While it’s always nice to be cited, it would be inappropriate to cite our work (the “large-scale” study cited above) as supporting the hypothesis that Clojure is less bug-prone. This is not the correct conclusion to draw from our paper. Our paper in fact makes clear that despite statistical significance, our analysis demonstrates no practical difference between C++ and Clojure:

      2. 11

        First, “using the REPL” does NOT mean typing your code in REPL. Heck, no, it’s the opposite.

        “Using the REPL” actually means typing your code in your favorite editor. [..] Obviously, this requires some upfront setup,

        Another head-to-desk moment for me, similar to the time I found out I was right all along that Haskell’s foldl was stupid, while I thought all along the problem was me not getting it.

        1. 5

          Yeah - there is an interesting thread about this name - REPL-driven development - on ClojureVerse. One of the better suggestions is to call it “Interactive Development”. It would indeed probably be less confusing.

          1. [Comment removed by author]

            1. [Comment removed by author]

              1. 5

                You’re right. Was just annoyed. Post removed.

                1. 5

                  👍 deleted my callout in reciprocity

          2. 1

            Sounds more like a cult to me?

            1. 5

              Why? Is there something in the article that paints it as a cult? What’s in your opinion, makes Clojure ecosystem and/or the community around it sectarian? How is it different from Golang, Swift, C#, Ruby, Python, Haskell, etc.?

              1. 2

                I didn’t mean to say I think Clojure is a cult, I don’t believe that. But that article makes it seem so, to me. A little bit too strong on the “if you don’t agree you’re not clojuring hard enough” angle.

              2. 1

                Sure accurate. Cults normally are not traditionally productive.

                1. 3

                  I’m not sure I follow your comment. Are you saying that Clojure makes you more productive by breaking established conventions, standards, or practices?

                  I think it’s quite the opposite. Clojure follows a long-lasting tradition of Lisp. Lisp always has been a powerhouse, like it’s meant to be the best tool for quickly prototyping programs.

                  1. 3

                    I think Clojure is to lisp as javascript is to java. Real Lisp programming is built around the cons cell. Clojure is built around the underlying available data structures, with a tidy interface for using them. Clojure is built around the seq. Lisp is built around the cons. Clojure uses some of the best of lisps, like consistently low syntax, wrapping expressions as forms using parens. Sure, it looks like a lisp, and quacks a bit like a lisp, but lisp hackers are likely to find it a different experience.

                    As for the cult aspect, I mean Clojure helps make people productive by: encouraging flattening the call tree, supporting interactive development including of running systems (test why something fails in prod, from inside!!), discouraging mutating state, and encouraging cutting through the waste of so many APIs with simple clean interfaces to the world. Clojure helps make people productive by discarding the useless faffle we’ve come to associate with properly designed systems.

                    1. 7

                      Clojure helps make people productive by discarding the useless faffle we’ve come to associate with properly designed systems.

                      This is one thing I’ve found to be true of the Lisp world in general; there’s often a lot of attention given to the APIs, to make them clean and simple, and reducing things to the essence.

                      That’s more of a cultural thing, I guess; I’ve seen similar sane APIs in other languages (Python’s requests library comes to mind), and I’ve also seen annoying to use or badly designed APIs in Lisps.

                      As to the article, it reeks of smugness and the writing style is hyperbolic and lazy (as others have pointed out, even the quoted research seems to be shoddy). In my experience, what matters far more than the language is the experience and synergy of the team. A team of two experienced developers who have a mindset of shipping can get infinitely much more done in any language than a large team of less experienced developers or even a small team of experienced developers who don’t communicate well, have very different worldviews or who let their egos get in the way of building code that works.

                      Of course, a well-oiled team will typically gravitate towards the language they (as a team!) find most productive. Ironically, that doesn’t have to be all (or any) of the members’ favourite language.

                      1. 1

                        Real Lisp programming is built around the cons cell.

                        What do you mean by this? I’ve been hacking on Common Lisp for years and this doesn’t mean anything to me. If you mean the literal cons cell data type, I strongly disagree - you could replace the cons cell with a Python-like list where you can’t reify a reference to the tail/cdr and most people would be 99% as productive. If you mean “the list datatype in general”, then I’m less opposed but still not convinced.