Clojure Gazette 102

Code-gen, Grief, Pixie

Clojure Gazette

Issue 102November 16, 2014


Hi Clojurists,

Woah! So excited about Clojure/conj!

Since I've finished the core.async videos , I have recovered a bit from the many late nights it took to get them finished. And I've been devising plans for an even bigger and better 2015 for LispCast videos and the Clojure Gazette.

I get a few readers every week who tell me how much they enjoy the Gazette. I love hearing from you. I love hearing suggestions, complaints, joyful exclamations, and random thoughts. Thanks so much for being awesome.

Enjoy the issue!

Rock on!
Eric Normand

PS Learn more about the Clojure Gazette and subscribe. Learn about advertising in the Gazette .

Sponsor: LispCast

Is sponsoring your own newsletter tacky? Well, maybe, but I was so excited to finish the LispCast Clojure core.async videos that I had to tell everyone I know. Have you ever wanted to learn core.async? Then these videos are a great introduction. After watching the animations, doing the exercises, and following the explanations, you should have a solid understanding on which to build more.

Using Clojure To Generate Java To Reimplement Clojure

Much of Clojure is implemented in Java. The data structures are all implemented in Java. And that can be tedious. As good as the JVM JIT is, hand unrolled loops can still yield a lot of performance benefits. In this article, Zach Tellman talks about his efforts to implement special-case collections for PersistentVector and PersistentMap of specific sizes, and also how to unroll loops for array implementations of Vector and Map. It just makes me think of how tedious language implementation is.

The Sixth Stage of Grief Is Retro-computing

Wow. The grief over a friend's death sends the author on a journey through the annals of the history of computing, as seen through emulators that are still available today. Perspective over 30-40 years of innovation, fueled by existential crisis, and distilled into a beautifully written blog post.

Immutability, or Putting the Dream Machine to Work Youtube

Often, in history, revolutions must redefine their past in order to define the future. It's not that history gets rewritten, simply that, while crafting a narrative, different important events are selected from the past in order to craft a compelling story.

The story of object oriented programming, the dominant paradigm at the moment, has the most mindshare right now. It weaves a tale of encapsulation, domain modeling, and code reuse. In this talk, David Nolen gives functional programming its own narrative, mostly divorced from the impotent "mathematical reasoning" trope. Instead, he tells a story of interactive computing, of the influence of Lisp, and of the increasing performance of persistent data structures.


If you're into programming language implementation, like I am, this new language should be very exciting. It uses a relatively new technique called Tracing JIT compilation. An interpreter is created for the target language. And when the program enters a loop where it loops many times, the instructions that the interpreter executes are recorded until it loops back around. That recording is called a trace. The trace is optimized and then the next time through the loop, that trace is executed directly. It's fun stuff because you can write a tracer for a given bytecode once and use it on many interpreters.

Clojure/conj 2014 Unsessions

If you're going to the Conj, go check out the unsessions. These are community-selected sessions that are organized in different ways. Some are demos. Some are workshops. But they need us, the attendees, to choose what they want to see. Go put your name down under the ones you want to go to.


A kind reader pointed me to this static site generator in Clojure. It's new. Check it out if you'd like to contribute.

The Programming Language Wars Vimeo

We, as an industry, are beginning to do quantitative research into what kinds of programming practices and language constructs contribute to error rates and productivity. This research is enormously useful. It's all very basic stuff right now, and it seems to look at language features in isolation. But eventually, when we have a body of knowledge to work from, it seems at least possible that we could build methodologies to design languages that are based on hard evidence. Of course, then you need to test the new language as a whole. The methodologies are the most important part.