Chas Emerick

It was a blog about Clojure 6 years ago; 2003 is too far back. https://web.archive.org/web/20100415161333/http://muckandbrass.com/ In 2011, it was redirected to this blog, which is still live: https://cemerick.com/

Actually I completely disagree with you. Coming to Clojure with absolutely no lisp or functional programming background (and little java experience), and while it's been challenging to learn a new way of thinking, it wasn't hard to find documentation, read source code, or ask a question in #clojure. Leiningen really made the process more streamlined. http://cemerick.com/2012/05/02/starting-clojure/ http://clojure-doc.org/ http://clojure.org/cheatsheet and (source <thing>) have been great resources.

Some of us have been "marketing" Clojure for a number of years now. :-) The results from the last two years of the survey (e.g. 2011's are here: http://cemerick.com/2011/07/11/results-of-the-2011-state-of-clojure-su… might be illuminating for you. Clojure has a ton of compelling use cases, but it's stubbornly not going to fit into the shoebox of a single domain. Thus, it's going to be hard to say, "Clojure is great because it allows me to address narrow problem X". It's a general-purpose language, and increasingly, a multiplatform/multienvironment one as well. Also, only ~7% of the respondents to last year's survey came from a Lisp. Most come from Java, Ruby, or Python. Make of that what you will re: Clojure's "weirdness".

I will give my answer, noting that not everyone will agree with me :-). The vast majority of software developers do not put up with Lisp syntax. The vast majority of software developers use a different programming language with a much better syntax, and never consider using Lisp for anything serious. For example, for most developers, a programming language is a laughable nonstarter if it cannot use infix notation for basic arithmetic, as that is the standard notation for mathematics worldwide and is taught to everyone. As evidence, look at TIOBE: https://www.tiobe.com/tiobe-index/ ... you'll see "Lisp" is #26, lower than Classic Visual Basic, Kotlin, Ada, and SAS. Scheme and Clojure aren't even in the top 50, so adding them wouldn't change much. Lisps will never break the top 10 with their current syntax. There is a reason for Lisp's syntax: it's homoiconic, enabling powerful macros. Lisp macros are incredibly powerful, because you can manipulate programs as data. Other macro systems generally don't hold a candle to Lisp's. The vast majority of "simple syntactic sugar" systems for Lisp lose homoiconicity, ruining Lisps's macros. This was even the problem for the M-expressions created by Lisp's original developer. Most of those syntactic improvements also tend to NOT be backwards-compatible. There is a solution. I developed curly-infix expressions, SRFI-105 https://srfi.schemers.org/srfi-105/ Curly infix enables infix notation WITHOUT losing homoiconicity or requiring a…

> I think it's worth pointing out why the author's of SICP themselves acknowledge why it was phased out. Gerald Sussman made some remarks about this during an unrelated roundtable discussion at the 2009 International Lisp Conference: https://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-sch… Note that Sussman did not actually state why the committee decided to change the curriculum. The remarks about studying software empirically were his opinion. I was in the audience, and while Sussman seemed sincere in his remarks, I still have a hard time believing he was serious. How can anyone state, without irony or sarcasm, that we should just give up, and start treating software programs, where all the "laws" are not only known, but made up, by us, as if they were natural systems, where our only way to understand them was to start "poking" (I may be wrong, but from what I remember this was the actual word Sussman used) at it and observing the results? If you give up before you have even started on modularity, composition, etc., and start treating every program as if it was a million line COBOL hairball, the hairball part is just going to be a self-fulfilling prophecy. My takeaway from Sussman's remarks was the opposite of his message - the ideas about applying mathematical principles to software design in SICP have become even more relevant as a way to prevent software hairballs. I make good money doing the "poking," but if you…

I think Christophe's is the talk, and Yegge seriously misunderstood it, if he even bothered to watch it. Christophe's point was that basing the underpinnings of a DSL on macros was frequently a mistake, vs a data + functions approach that "leads to greater dynamicity". It is inarguable that macros are less flexible than functions (e.g. they can't be applied) and less composable. Christophe's argument wasn't against macros, but that they should be the last layer of sugar, not the core mechanism of a DSL. This approach has been advocated and practiced by Lispers forever. Ditto the advice to not use a macro when a function will do. And for Yegge to imply that more serious Clojure devs like Christophe are macro averse because they are afraid they might not understand someone else's macro code shows his complete lack of familiarity with Christophe's macro skills and other work of the community. Taking potshots at things you don't understand and people you don't know (while leaving out the link so others could verify) smells like a FOX-news rhetorical approach to me. Ditto political labeling (though in the programming community the negative tag is "conservative", whilst in politics it is "liberal"). Tag the thing you don't like with the negative label, then rationalize, and spew misinformation. "Clojure's community came pre-populated with highly conservative programmers from the pure-functional world: basically Haskell/ML types": surveys[0][1] say... nope. He even ignores the…

Another article on the same topic: > https://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-sch…

A few years when MIT switched from SICP/Scheme to Python, Sussman had this to say: "I asked him whether he thought that the shift in the nature of a typical programmer’s world minimizes the relevancy of the themes and principles embodied in scheme. His response was an emphatic ‘no’; in the general case, those core ideas and principles that scheme and SICP have helped to spread for so many years are just as important as they ever were" From: https://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-sch… If anything, I would think Sussman is more practical, and understands what the world needs/expects(now). Literally any programmer who hasn't read SICP before will benefit from it. I think the principles still apply.

Most Clojure programmers are Java programmers - http://cemerick.com/2012/08/06/results-of-the-2012-state-of-clojure-su… Even though this is 2 years old it's still the case that the Clojure folks are heavily dominated by users who have already invested in the JVM. The other largest group seems to be split evenly between Python & Ruby as reflected in this survey.

If you have a better workflow, by all means use it and share it with us. If you want to see a community-oriented look at Clojure based on self-reported data, I'd suggest the 2013 State of Clojure: http://cemerick.com/2013/11/18/results-of-the-2013-state-of-clojure-cl… I think you'll find considerable diversity in Clojure. You've got a confluence of people coming from Java, Ruby, Lisp, and other languages. You've got enterprises and start-ups using it. This diversity is certainly one reason that Clojure is so popular and useful to so many people.

The things he said about the Clojure community are in contradiction with the data from the 2012 State of Clojure survey here: http://cemerick.com/2012/08/06/results-of-the-2012-state-of-clojure-su… . Steve claims that Clojure folks come from the Haskell/ML world when the survey lists the "former primary language" of survey takers to be 1% Haskell, 0% SML, 0% Ocaml. Whereas they actually come from Java, Python and Ruby mostly. The Clojure "replacement" in the survey is all over the map with Common Lisp, Erlang, Haskell, Java, Python, Ruby, Scala and Scheme all performing well. The liberal/conservative thing is a false dichotomy and Clojure community is probably living proof of that.

No, just referencing a well-known event; but it seems you're right that he's not teaching that course any more http://news.ycombinator.com/item?id=531490 However, he did say that starting off with python makes an undergraduate’s initial experiences maximally productive in the current environment. http://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-sche… fun fact: norvig switched to python (for his textbook) http://news.ycombinator.com/item?id=1803815 It's horses for courses (or ophidia for courses in this case).

I've heard that actually students who had never programmed before did better with SICP than students that had. You have to un-learn a lot of habits from imperative languages when you start working with Scheme. Total novices could take the material as it was presented, but people who had programmed before often tried to shoehorn it into the C/Java/PHP paradigm they'd already experienced and ended up fighting the language. The same effect worked in reverse as they graduated MIT or worked on projects in more mainstream languages, though. Students would have to unlearn some of the elegant recursive formulations and strong abstraction abilities of Scheme and deal with languages that actually have strong industry adoption. That was a major factor [1] in the replacement of SICP with Python in MIT's intro programming class. Python has abundant library support that more closely mimicks what the programmer will have available and what challenges she'll face in the real world. [1] https://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-sch…

Reading a short account of the rationale behind the change, described by Sussman himself, paints a very different picture: http://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-sche… . It's not that programming now "largely consists of debugging and customizing already existing code, often via frameworks". For one thing, it's only the narrow, web-constrained definition of "framework" that even vaguely works that way. Second, I'd argue that, unless the code which programmers debug has been written somewhere until the late 1990s, new code gets written often enough that programming largely consists of writing new code instead of debugging old one. That there are programmers hopelessly churning on the umpteenth bug because someone at the end of the Internet decided to change the format of their JSON objects and the mapping of their HTTP request handlers (pretentiously calling that "an API") is not a testament to how programming has evolved, it's merely a proof that not every change counts as evolution. Instead, the choice of Python over Scheme -- which has been received with mixed feelings by almost every programmer able to write a Quicksort function without googling for compiler errors -- seems to have been driven by related, but vastly different reasons, such as: * There are vast amounts of interactions spread over multiple languages, machines and platforms. Independently reasoning about objects, while essential to programming,…

Also don't miss (in no particular order): Tutorials http://github.com/relevance/labrepl (gives a kick in terms of functional thinking, use of higher order functions etc) http://www.try-clojure.org/ http://4clojure.com/ https://github.com/functional-koans/clojure-koans Documentation http://clojuredocs.org/ http://en.wikibooks.org/wiki/Clojure_Programming http://www.clojureatlas.com/ (Finding functions by browsing the relations of APIs and API-functions is just to nice) http://cemerick.com/2011/07/05/flowchart-for-choosing-the-right-clojur… http://clojure.org/cheatsheet http://www.clojure-toolbox.com/ (not up-to-date) I'm sure i missed something, but those links can really be helpful.