Clojure and the future for programmers like me

TL;DR: Attitudes common in the Clojure community are making that community increasingly unappealing to people like me. They may also be leading to a language less appealing to people like me than a Lisp should be.

I think people like me are an important constituency.

The dodgy attitudes come from the Clojure core, especially Rich Hickey himself, I’m sad to say. I wish the Clojure core would be more supportive of programmers not like them, and of those with different goals. Otherwise, I’m afraid Clojure won’t achieve a popularity that justifies the kind of commitment I’ve been making to it. What should I do?

I’ve caused a bit of kerfuffle on Twitter about Clojure and testing. I’ve been somewhat aggressive because I’m trying to suss out how much effort to put into Clojure over, say, the next year.

[Note to the reader: scatter “I think” and “I could be wrong” statements freely throughout the following.]

Here’s the deal.

What’s at issue is a style of working (roughly XPish). After some years of work by many, it’s entirely possible in the Ruby world to work in that style. After doing the whole Agile spokesmodel thing for a decade, that’s all I want: a place where there are enough people with my style that we can (1) find each other to work together, and (2) work together without having to re-justify our style to every damn person we meet. In Ruby, XP style is mainstream enough that we can let the product of our work speak for us. (Hence, my recently co-founded contract software company.)

I think it was at the 2nd RubyConf that Nathaniel Talbott introduced Test::Unit, a Ruby version of jUnit. I can’t be positive, but I’m pretty sure Matz (the author of Ruby) didn’t care all that much about testing or, especially, TDD. Wasn’t his style. Perhaps still isn’t. However: he did not, to my recollection, express any reaction other than his usual “People are doing things with my language! I am happy!” And while Matz gives keynotes about design and such, they are pretty obviously about how he feels about design and about how he approaches it. They are invitations, not instructions.

One of the strengths of Ruby in the early days was this air of invitation. (I don’t really follow that community closely any more.)

Rich Hickey, for all his undoubted brilliance as a language implementor and his fruitful introspection into his own design process, presents a less welcoming demeanor than Matz’s. From what I’ve seen, he is more prone, in his public speaking and writing, to instruction than to invitation.

Which is OK with me, all things being equal. But there’s a problem. Brilliant solo language designers set a tone for the community that gathers around the language, especially in the early days. We’ve seen that with Python and Ruby. (Rails too, which acts as a contrast to the “Ruby Classic” tone.) It’s happening again in Clojure, where I’d say the picture of the ideal developer is someone who, with grim determination, wrestles a hard problem to the ground and beats it into submission with a multi-issue bound copy of The Journal of Functional Programming. I’m all for people who do that! So I don’t have to! But I personally prefer something more akin to the style of Ruby’s _why, who’d sneak up on a problem and tickle it until it was laughing too hard to be a problem any more.

I didn’t always prefer the Ruby style. Just after I started my first post-graduate job, Tony Hoare’s Turing Award lecture came out, containing the famous quote:

I conclude that there are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.

I positively thrilled to that. That was the man I wanted to be.

As time went on, though, I ran into difficulties. What if you can’t solve the problem with that first method, whether because you’re not smart enough, or the problem domain is inherently messy, or the problem keeps changing on you? What then? Do you just give up? Or do you try to find a third method?

Those difficulties, plus some timely encounters with some strange thinkers, notably Feyerabend and his Against Method, put me on my current career path. Which causes me to say this:

For someone doing core infrastructural design, such as the huge task of tricking the JVM into running a Clojure program speedily, an emphasis on purity and simplicity—one bordering on asceticism—seems to me essential. God speed Rich Hickey for that!

But when a community adopts purity, simplicity, and asceticism as core tenets—ones approaching matters of morality—you can end up with a community that makes things unpleasant for not just the impure and hedonistic, but also for just plain normal people. And they will go elsewhere.

Much as I love Lisp and admire Clojure, if it can’t grab the enthusiasm of, say, the median pretty-good Ruby or Java programmer who has the TDD habit, it’s not economically sensible for a cofounder of a new company to put as much effort into it as I have been putting.

If Clojure turns into a tool for hardcore people to solve hardcore problems, without making concessions for people with softer cores—if it remains a niche language, in other words—I should probably spend more time with Ruby. And I do think, right now, that Clojure is more likely to be a niche language than I thought last year.

So in the last few weeks, I’ve been sending out little probes, mainly to see if anyone with some star power can provisionally buy the story above. If so, I can hope to see an intentional broadening in a direction designed to shackle me and those like me more tightly into the Clojure community—and so help it succeed.

So far, meh.

If I’m sensible, a continuing “meh” response will prompt me to reduce my effort around Clojure—to resist the temptation to make another tutorial, to cut back on new Midje features (but not on fixes and the 1.3 port, I hasten to reassure its users!), and so on. If Clojure then wins big, I can jump back on the bandwagon. I will have lost some early mover advantage, but that doesn’t look to be huge anyway. (Not like it was with Agile, or would have been with Ruby if I hadn’t drifted away before Rails came out.)

I haven’t decided what to do. Reaction to this post might help. Probably the best thing would be for me to be convinced I’m nuts. Hey, it’s happened before!

A postscript on the validity of what I claim

A postscript on worries about the effect of performance on expressiveness

25 Responses to “Clojure and the future for programmers like me”

  1. Exploration Through Example » Blog Archive » A postscript about the validity of claims Says:

    […] problem with talking about the tone of the Clojure community is that almost no statement can ever be proven. Rich Hickey and I went around and around about this […]

  2. fogus Says:

    > The dodgy attitudes come from the Clojure core

    As a member of Clojure/core I must say that I would never begrudge you the tools and processes that make you an effective designer and programmer. I respect your work in the Clojure community and think that it would be ashamed to see you leave.

  3. abedra Says:

    As another member of Clojure/core I would like to offer the same sentiment as @fogus. What you are and have been doing has helped spread the adoption of Clojure and I am grateful for it.

  4. stuartsierra Says:

    Speaking as another member of Clojure/core, I want to second what Fogus said. Use whatever tools or processes make you effective.

    I also want to say that Clojure was designed to be “a tool for hardcore people to solve hardcore problems.” That’s what Rich Hickey wanted, and that’s what he built. He’s a hardcore person, and like many such people, he isn’t shy about expressing his opinions. Don’t take it personally. (And don’t try to hold a cogent dialogue on Twitter ;)

    Yes, Rich Hickey doesn’t like TDD. I’m kind of meh on it, and I’ve written two Clojure testing frameworks! But it’s not a moral judgment. We’re not trying to drive anyone away. If anything, we’re trying to find our way to the next evolutionary step on that path. Maybe clojure.test.generative is that step, maybe it isn’t.

    I sincerely hope that Clojure can continue to be valuable to both hardcore and “softcore” users. I believe it’s possible. Speaking for Clojure/core, we’re interested in the hardcore problems, so that’s where our (extremely limited) time is focused. The softer side — tutorials, documentation, user-friendliness — will perforce be left up to the community. But we value those contributions just as much as the latest JVM performance tweaks.

  5. nathanmarz Says:

    It seems to me this post stems from some of the comments Rich Hickey made about TDD during his keynote at Strange Loop.

    I was at that talk and didn’t take his comments to be anti-testing. He was simply saying that TDD is not a magic method to achieve simplicity in programs. His point was that simplicity and complexity are deep concepts that many developers have failed to grasp, with “easy” often mistaken as “simple”. I agree 100% with that, and I don’t think that point precludes the value of unit tests. In fact, I believe strongly in having extensive unit tests (and I’m a big fan of Midje).

    Rich’s extensive use of metaphor, while entertaining, seems to cause many of his points to be misinterpreted. In this case, people took him to be anti-testing, anti-agile, etc. Personally I thought it was a great talk with a lot of insights, but I can see how it could be misconstrued.

    Just my two cents.

  6. benfulton Says:

    I was at the talk too, and it was great. But he did make some comments like, “Tests are like guard rails, and you don’t steer your car by bouncing it off the guard rails until you find the destination.” Couple that with some quite rude statements on Twitter - “Almost all of your tweets have been wrong”; “You are just making up how languages ought to work” - and I am very much reminded of some of the arguments that went round and round interminably on talk.* groups on Usenet in the 1990’s. We should be past that.

    That said, there is a long tradition of brilliant computer scientists that do not suffer fools gladly, such as Dijsktra, and I don’t think it has too much bearing on the language. If you’re looking for a nicely designed, functional, immutable, language, you certainly don’t have to look much further than Clojure, and I don’t think that Hickey’s personality is going to have much to do with Clojure’s success or lack thereof.

  7. Chas Emerick Says:

    I’ll second the sentiment that Twitter is probably the worst possible venue to attempt discourse — worse even than irc, where misunderstandings and misinterpretations of tone are trivially easy to come across.

    As you said in your followup post (

    I’m not saying Rich Hickey’s design approach is wrong. I suspect for the kinds of problems he solves, it may even be true that his approach is better across all designers than TDD is.

    It seems then that your primary issue is one of tone, not substance. (Not criticizing here, just attempting to restate the gist of your point.) You want to be able to work how you want to work with like-minded collaborators “without having to re-justify [y]our style to every damn person [you] meet”. Totally understandable.

    But, aren’t you doing this already? Midje seems to be a big hit (e.g. just today: That’s awesome, and I don’t think anyone would begrudge you it, your methods, etc. I certainly do my fair share of TDD when its appropriate, and I think testing in general has a very strong history in Clojure already (with clojure.test having been in Clojure from before v1.0, if memory serves); I really doubt testing is going to somehow become gauche. I want to see Midje continue to flourish, along with N other testing libraries to properly plaster the solution space.

    Regarding the roles of language developers: there’s no hard-and-fast rules (or even flappy-and-sluggish guidelines) about what works and what doesn’t when it comes to building “successful” languages (in quotes because even ’successful’ is a hairy concept to define). All there is, is anecdotes. My convenient counter-example would be Guido van Rossum. He’s not much of a fan of functional programming, and was hoping to eliminate lambda, map, filter, et al. from Python — but finally relented and left them in a hobbled, fossilized state.

    In contrast, the wonderful thing about Clojure is that you can do nearly anything you want without needing the language designer’s permission or approval. This is where you really lost me: what “concessions for people with softer cores” does Clojure need to make, when the language is permissive by default with regard to methods and approaches? I don’t think you’re referring to documentation, tutorials, installation processes, and so on, though those are being refined forthwith. Don’t “hardcore” users want the same fundamental bits that “softcore” users want, perhaps modulo some additional / different abstractions? The latter sounds like something for which an expressive, efficient language like Clojure is well-suited, and a capable developer like yourself is well-matched.

    Finally, tangentially: we all have opinions, and I personally enjoy having mine challenged — either I can effectively argue away such challenges, thereby reinforcing my beliefs, or I may find myself to be wrong in some way, giving me the opportunity to make a course correction. Conferences like Strange Loop are particularly wonderful opportunities to be challenged, presumably by those best equipped to do so. I’d be sad if any presenter in such a setting were to dilute or elide their own convictions; I don’t think that would be fair to them or useful to me.

  8. unclebobmartin Says:

    Just for the record: Rich may not suffer fools lightly; but Brian is not a fool.

  9. unclebobmartin Says:

    Speaking as someone who has both started and ended companies: Brian, ya gotta do what ya gotta do!

    If I were starting a software contracting company today, I would *not* base it on Clojure. Ruby is where it’s at right now, and you’ll get a lot more business by being really really good at it. (Frankly, what I’ve seen of the ruby code being written right now leads me to think that you could make a big contribution because, oh man, these kids are making a mess of it )

    However, I would not back away from Clojure in your private and open-source explorations. The whispering winds I listen to (perhaps they just blow in the space between my ears) tell me that Clojure, or a language like it, is going to be dominant in the next decade or so. Those winds all seem to be blowing in the direction of a simple, functional, lispy language. The winds also tell me that Ruby is going to peak in the next 4-5(ish) years .

    For my part, is pure clojure. Micah wrote it; and I’ve been studying it in my massive spare time. What I’ve seen, so far, is that you _can_ apply clojure to real world problems, and it works very well indeed. I’ve also seen (surprise, surprise) that feeble minds like mine absolutely require TDD to get things done quickly and accurately.

  10. manuelp Says:

    I’ve just started to study Clojure and functional programming, but I want to bring my two cents.

    In software development, a lot of projects have incomplete/unstable requirements, several peoples working on it and several times it’s necessary to refactor some part of the application to accomodate new requirements and more understanding of the problem and solutions required. TDD have too many advantages in this context (I’ve seen them).

    Maybe with LISP(s) is diffent. Maybe Clojure is so expressive and concise that you don’t actually need to do TDD. I don’t know, I hope that someone much more experienced than me could clear these doubts. However, in the book “Clojure in action” there is a chapter dedicated entirely to TDD, so I suspect you can’t really get away without TDD for big, enterprise applications.

    These are the facts as I know them: Rick doesn’t practice TDD (in fact he finds it a “waste of time”), but several other clojure/core contributors actually do. There is even a suite of tests that backs up clojure/contrib (perhaps even clojure/core) that Rick regularly runs. Probably clojure/core is sufficiently small and Rick has spend so much time and thinking on it that he knows the code inside-out. But I think that even if that style of development maybe is suistainable for Clojure itself, it’d be couterproductive on other projects.

    Regardless, I think I’ll continue to study Clojure and try to find my answer. I think it’s a very important and interesting discussion.

  11. Brian Marick Says:

    Thanks for all your comments. I do want to emphasize that my focus is on tone and how that can damage a community. I lived quite painfully through one community’s collapse into a niche when its core ideas deserved better. Once burned, twice shy, as they say.

  12. objo Says:

    Well, it doesn’t have to end in collapse, no matter what the tone is.

    RailsConf had yet another successful conference with thousands of users despite the ‘leader’ at the top. I spoke at the first ever Rails conference in Canada. Stood up right after David had his infamous f- you to the enterprise slide to give a talk on SOA on rails. Many, many people have dealt with his tone and simply kept doing great work despite what he’s said. Anyone remember how ‘out of touch’ they claimed Dave Thomas was at that conference? I don’t hear that anymore.

    When it came to testing, rails was always (and still is) incredibly far behind. Out came Test::Rails, rspec, shoulda and a host of other things that made life better. David actively called them out as a waste, and you continued saying people just ‘get things done’ yet they thrived anyway. And most of us (even those doing evil enterprise work) have thrived quite well.

    Yes, I’m very thankful to him for Rails, but I don’t look at him for guidance on problem solving. I love the tool, but am damn good at solving problems and helping build teams (many of which require ‘n00bs’) without his ‘guidance’.

    No, I’m not commenting on Rich Hickey as a person by any means. I’m not trying to draw conclusions between him and dhh as I’ve never met him in person, nor listened to him speak (although from what I hear, I need to make time to change both). I’m simply stating, that reading your posts above I can’t help but think you could be spot on (again, I have no background other than your posts to go off of). I also can’t help but recall arguments we have had in the Rails community over the last 5 years.

    Rails was a great tool that did great things. What made it so popular and so effective though were the countless champions in the community that pushed it, despite messages from the top, not because of them. Don’t expect the implementers (or core members even) to carry the community flag if you feel it needs to be carried. Be that leader yourself.

    Good luck.

  13. tristan Says:

    Brian: Firstly, you are responsible for me actually trying to write something in Clojure. Your screencasts and Midje both encouraged me to get going (and Midje in particular persuaded me to try Clojure rather than another Lisp)

    Previously I had been somewhat put off by what I’d seen of Clojure, both hearing poor things about the attitude of the community and some misgivings about aspects of the language - and that’s speaking as a lisp/scheme fan who should be attracted to a language like Clojure.

    So you and others like you have an effect on mitigating the off putting attitudes that others bring. I hope that it can continue and a community of more like minded people can grow.

    Personally, I’ll be continuing in Java land for the day job but in my own time I’ll pursue Clojure for a bit longer. Its already making me think hard about structuring code for clarity and maintainability with Midje pointing out potential smells, even in very small pieces of code.

  14. puredanger Says:

    Brian, while I can’t possibly comment on what you should do with your business, I do hope you stay involved with the Clojure community. I greatly value your contributions.

    Regardless of what you believe Rich is about, my impression is that the community is wide and there are many schools of thought. I welcome a diversity of opinion with respect to how to build software. There are many kinds of software, many kinds of people, and thus many ways to succeed (and also many ways to fail :).

    We have a large (~60k Clojure, roughly half tests) code base at Revelytix. We frequently discuss pros and cons of how to build tests that add value without adding drag, or how to evolve an API, esp with respect to top-down vs bottom-up. Midje frequently comes up in these discussions as it lets you defer choices. At times that seems at odd to me with the data-first Clojure bias and at times it seems very harmonious. I’m still working out what that means both wrt Clojure and wrt my code. :)

    Re Rich’s Strange Loop talk, the video will be out soon and I think that will help give some greater context around the twitter feedback. Hopefully, that will help with some additional perspective.

  15. ksteffe Says:

    Brian: I want to echo the crowd here and say that I hope you stick it out with the Clojure community despite the recent frustrations you have encountered. My reasons for thinking so are both selfish and simple. I am constantly delighted by what I learn from Clojure and the community and I’m constantly delighted by what I learn from you (including Tango dancing). While I doubt my selfish reasons are all that convincing, I’d like to turn these reasons on their head slightly.

    That is to say, that I presume there are good things about the Clojure language (some that are easy to articulate, others not so much) that drew you into it in the first place. For some folks it may be the Lisp-y goodness that they never wanted to let go of in college, for others it is the mental high from having your Object Oriented brain stretch in directions you never knew existed.

    And as long as that passion and love for the technology exists, let it fuel the motivation that it takes to drive out what you hate (or maybe dislike) about the community. If strong-minded folks continue to ignore your passion, then give them what they deserve and ignore them back while you continue to deliver more innovation. In the end the egos melt away when no one can argue with results. Making arguments with analogies (e.g. driving with guard rails) hold an equal amount of weight as the rhetoric present in the comments I’m typing right now.

    Finally, I think many communities (whether technological or otherwise) often have a silent majority that often goes unnoticed. It takes time to find the right questions to ask them in order to uncover the unknown unknowns. The real vibe of the community may not be what it seems. And even if it is, that’s no reason to stop doing something you love.

  16. manuelp Says:

    Ok, a few more thoughts. If you happen to write code using TDD (as I do), and you find it useful than no one is stopping you from doing that. Even if Rick doesn’t write code test-first, there are a lot of other people that do it and it seems to me that no core contributor to clojure/core is criticising your preference or obstructing your efforts.

    As an example, I agree with objo (comment #12). In the Rails camp, even if DHH is a proponent of plain old Test::Unit there are a lot of people that use RSpec and Cucumber to write their application. In fact, there is a strong emphasis on testing with these frameworks regardless of DHH’s preference of Test::Unit. I don’t think that the tone can damage the community (or at least I hope so).

    Having said that, your Midje project is awesome and I’ll certainly use that. So I hope that you will remain involved with Clojure and Midje because I think a lot of people would benefit from that (myself included).

  17. Brian Marick Says:

    Thanks for your thoughtful comments. I’m inspired by your thoughts that there’s space for the kind of diversity I believe is important.

    I have two questions.

    [Note: a mailing list might be better for discussing at least question 1. Sorry that my blog software is antiquated.]

    1. Stuart Sierra writes:

    Speaking for Clojure/core, we’re interested in the hardcore problems, so that’s where our (extremely limited) time is focused. The softer side — tutorials, documentation, user-friendliness — will perforce be left up to the community. But we value those contributions just as much as the latest JVM performance tweaks.

    While I believe in altruism, I also believe people do things for rewards, even if the reward is something as intangible as the (explicit, stated) approval of people you care about. Part of the risk I was talking about in my original post is that a clojure/core interested in hardcore problems means the route to approval is through hardcore problems, not tutorials, documentation, user-friendliness. That is, any reader of the mailing list would likely know that the big win is writing core.match, not writing a tutorial. Or suspect that a paper submission including touchy-feelie people-in-teams stuff stands a worse chance being accepted to the Conj than one that’s strictly technical or about individual problem-solving.

    That way, I was–am–afraid: lies The Niche.

    [I am not criticizing David Nolen for core.match! In the slightest! Without knowing hardly anything about it, I want to write a macro to do Haskell-style multimethod definitions.]

    If there’s a need for “soft” things, there’s a need for rewards for “soft thing” people. For those who explain. For those who push Clojure into other communities (like the London TDD crowd, like the Agile crowd, like the gosh-wow and whimsical crowd).

    How can that happen? What rewards would there be? How would what I think of as “clojure/apple” or “clojure/softcore” be enough of a “thing” that it could balance or extend the community centered around clojure/core? [I imagine explicit approval by Rich Hickie would be important. But see below.]


    2. The “community collapse into a niche” example I mentioned in a previous comment might be described by the remaining core of that community as the ejection of a complete asshole (that is: me) after my true nature was revealed. It was revealed during a particular event (a workshop I organized).

    After that event, the remaining core (I’d once been a member) considered ideas and people that I was associated with to be radioactive. It was one of those bitter divorce situations where one partner could say “pie is good” and the other would immediately come back with “I can’t believe you’re fucking taking credit for all the pies I made! Back off, Buster!” My speaking up for someone in a technical/process dispute was ipso facto further evidence of its incorrectness.

    Judging from Twitter, it seems to me likely that Stu Halloway and Rich Hickie consider this blog post and associated twitter traffic to have revealed me as a complete asshole. True? [Note: my experience with techie types is that, when they consider themselves insulted, they disclaim it: “Why would I even notice what that person says?” Sometimes that’s true, but often it’s not. People are funny.]

    If I am persona majorly non grata, clojure/softcore should have nothing to do with me. I can write code or documentation, and keep my mouth shut. That means someone else needs to articulate whatever there is to articulate. I nominate @puredanger.

  18. puredanger Says:

    1) If you think there is not an audience for examples, tutorials, documentation, tools, etc I entirely disagree. Not just from the community-at-large but from from clojure/core. I’m not sure if you’re on the -dev list, but people in core are frequently soliciting and praising such contributions on -dev. I don’t know that you’ll see explicit feedback from Rich on those things, but imho I don’t think it matters.

    2) [I’m skipping your prior experience in another community as I’m not sure it’s relevant.] I don’t know what Stu and Rich think, but despite their considerable influence, they are not and cannot be “the Clojure community”. I see in the comments here many people saying a) you are providing value and b) please stay in the community. I think it’s vitally important that the Clojure ecosystem be wider than just Clojure/core, for many reasons.

    I will articulate my own opinions and I’m happy to be another voice in the crowd (outside /core). But I want yours too.

  19. Sean Corfield Says:

    My first reaction was to write a tart comment but (fortunately) your blog requires a registered login and I didn’t want to setup a WordPress account… so I started crafting a blog post of my own to respond to your criticism of the perceived tone “from the top”. That proved really hard to write so I caved in and registered with WordPress. I’ll probably end up writing two blog posts eventually but my desire to be tart has faded and the two blog posts will take a while to write because I actually want to address two completely separate issues, neither of which are directly related to the points you raise!

    So, back to your blog post. I’m a Clojure user who is not hardcore. I’m using Clojure as a general purpose language to build the model of a web application. I could use any number of languages but I’ve chosen Clojure because I like the concise expressiveness, I like functional programming and I like the JVM. I find the Clojure community as a whole to be extremely welcoming and helpful, more so than almost any other programming community I’ve been involved with in about 30 years. At the local Clojure user group, that sentiment was echoed - although the state of the “Getting Started” experience and documentation was criticized (and progress has been made there recently).

    I don’t find Rich’s comments to be at all snarky or off-putting. He’s a smart guy with strong opinions. I doubt he shares my opinions on a number of topics but that doesn’t affect my feelings about Clojure. Yes, there’s clearly some hardcore stuff being done with Clojure. I find it interesting to read about, even if it doesn’t apply to me and sometimes goes way over my head. Again, that doesn’t affect my desire to use Clojure.

    I actually found the Scala community to be more off-putting around the whole “Scala is hard” / “No it isn’t!” debate. That’s why I was particularly surprised by your comments about whether Clojure can grab the mid-range Ruby / Java developer’s attention. I don’t believe Clojure is hard and I don’t see any obstacle to doing TDD in Clojure. Given that a testing framework is baked into Clojure, and Leiningen creates a project structure that includes a test stub and encourages “lein test”, I’d say that Clojure ought to be pretty attractive to the TDD crowd.

    Back to some specifics of your question #1 - I was asked to submit a talk to the Conj on the real-world, general purpose stuff we’re doing with Clojure at World Singles. That’s a clear sign that the Conj is not just focused on hardcore stuff - that probably just reflects the sort of talks that folks submit. I didn’t submit a talk. I want to be able to enjoy the Conj, soak up the talks and relax. Maybe next year I’ll submit a case study on World Singles so there’s something softcore on the menu :) And then on to “rewards” for the softcore folks. I’m doing some softcore stuff around contrib, trying to help folks prepare for a migration to Clojure 1.3.0. That seems to be well-received and I’m actually a bit embarrassed by the nice things folks have said about it… So, yeah, the softcore stuff gets noticed and is appreciated.

    I’m sorry you seem to have taken some of the things that have been said so personally and, like the others in this thread, I hope you continue to work in the Clojure community.

    Finally, I think this quote is appropriate:

    “I am so happy with, and proud of, the Clojure community. People are helpful, and respectful, and positive. I think the key point is that the community values itself, such that people will decide it is more important to preserve the quality of the community than to vent their emotions or prove themselves right.” — Rich Hickey

  20. disclojure: all things clojure » This weekend in the Intertweets (Oct 2nd Ed) Says:

    […] A better explanation of why I am reconsidering my investment in Clojure. Talk me out of it. (via @marick) — So speaking of Midje, his author, a well known Agile proponent, is putting forward some issues he’s had with  the tone of some communications with Rich Hickey, and his (oh-so-public) stance regards Test Driven Development (or even Agile) or other popular request (e.g. better error reporting). In the light of these incidents Marick is wondering if issues like these are putting Clojure at a risk of becoming a niche language, and hence not worth making further investments of his time. Ugh, I hate to write about these things, i’d rather write about monads instead. In any case this cookie is relevant. Now, if we could try to find a common place in which we all win instead of all lose… […]

  21. Brian Marick Says:

    @puredanger and Sean Corfield: Both of you present some evidence I’m wrong. That’s good! I hope to see more evidence.

    Sean: perhaps you should join core to give heightened visibility to issues like contrib? Some sort of push to fix to address @puredanger’s todo list could readily be spearheaded by a core member who had committer rights to wherever the site source lives. Given a template, it shouldn’t be too hard to (for example) find someone to translate Colin Jones’ Clojure Libs And Namespaces: Require, Use, Import, And Ns into it.

    That could move very fast, provided there wasn’t a big commitment to getting it right, just better than now.


    One other thing: by using the word “hardcore”, I wasn’t trying to imply Clojure is a hard language or an elite one. (I don’t know if Fogus’s elite language post was in response to this one.) I taught 30-some Europeans Clojure last month. They found the class “mind exploding” (as one comment put it), but that’s because I was going for that: I wanted to show some of the “Wow, I never thought of programming like that” aspects of functional programming. But the language itself wasn’t a barrier.

    Let me make an analogy, and bear with me a minute before making judgment: Judging from watching my daughter, it’s not hard to learn enough about skateboarding to have fun and get modestly skilled. But a skateboard park that’s the hanging-out place for hardcore skateboarders can be intimidating to a newbie: there are matters of style that get enforced in a typical herd-animal way.

    Now, I am not saying “the Clojure group is just like a hardcore skatepark! Just like it!” I’m saying that it has the same sort of peer pressure undercurrents that happen in any social grouping, that there’s a particular tone that’s edging in an exclusive/niche direction, that it could be better, that it seems to me not to be getting better and maybe to be getting worse, and that a conscious push in a more inclusive direction would help most everyone.

  22. un.passant Says:

    Hi, thx for being able to keep such a calm tone over an issue that is obliously very dear to you.

    1°) It’s funny that you mention D.Nolen, because I’have the uttmost respect for core.match, but the reason I’d buy him a drink if we ever meet is his enlive tutorial :)

    2°) If your point of view is underrepresented in a community, leaving is not part of the solution, but part of the problem :(

    3°) I confess that I lack exposure to TDD but seeing news about Midje poping up on my Clojure radar, I was considering giving it a try : you might soon count me as a TDD convert thx to both R. Hickey of yourself.

    Best Regards,
    A Clojure lurker, grateful for any Clojure contribution be it libraries for/by mere mortals, tutorials and paradigm shifting rocket science futuristic language features

  23. clojurian Says:


    “I think the key point is that the community values itself, such that people will decide it is more important to preserve the quality of the community than to vent their emotions or prove themselves right.” — Rich Hickey

    Very good advice from Rich and one he would do well to follow.
    Some of the comments from Rich and Stu on twitter were far from that standard. (e.g. “troll” “good riddance” etc.)

  24. Exploration Through Example » Blog Archive » Top-down design in “functional classic” programming Says:

    […] me (and let’s not get into all that again), it usually works better to go top down, mainly because it lets me think of discrete, meaningful […]

  25. Who Is Dale Emery | Yves Hanoulle Says:

    […] Marick, who is never content to let a conclusion rest unquestioned. It’s delightful when he jiggles people’s “settled” ideas. Except when he […]

Leave a Reply

You must be logged in to post a comment.