The Fugue

I often find myself longing to be able to use Clojure, a very enticing lispy language that runs on the JVM.

I could possibly be using it right now in my dissertation research. It has the promise of dynamic languages, functional programming, almost-as-cool-as-Erlang concurrency, JVM performance, and Java library soup. It could be so awesome. A few months ago I started briefly down this road, unaware that…

Clojure sucks. Not generally, but it sucks for DSP. More specifically, Java and therefore Clojure has no real support for complex numbers. In order to do serious DSP, you need native syntactic, semantic, and performance support for complex numbers. Java has none of the above. Older versions of C didn’t have syntactic or semantic support, but the performance of using arrays was plenty fast. Not so in Java, at least not to the extent necessary to override the lack of syntactic and semantic.

So someday, when I’m writing general purpose code again and not high performance DSP code, I will have an opportunity to use Clojure, and I think that will make me very happy. By then the book will be out of beta. The community will be in full swing. There will be awesome libraries. Children will play in pristine parks with formerly-ravenous ravens.

In the meantime, if anyone sees the scene change, do let me know.

Levi pointed me to a presentation on Clojure, “a dynamic programming language for the JVM”. That’s actually a pretty bland description. I’d describe it at least as a dynamic functional concurrency-oriented lispy language for the JVM. The presentation was interesting, though I wish I had been able to follow the ant colony demo (it’s audio-only).

It awakened the oft-recurring “functional floundering” feeling. I’ve written a semester worth of scheme in a programming languages course. I’ve read the Erlang book and written a little Erlang code. I recently went through a graduate course in programming languages with emphasis on denotational semantics. I understand the lambda calculus, functional programming, etc. But I feel completely stymied whenever I think about actually programming in a functional language.

I’m not sure what the root is, but I’m sure it boils down to lack of practice. That undergraduate course aside, I haven’t had any practice. And since that course was very handholding (too much in retrospect), I don’t feel like I took any practical skill away from it. Yet I feel that in the future functional programming for concurrency will be important, even if I’m not convinced it will be essential.

So I don’t have time right now to really rectify the situation, but that doesn’t stop me from wondering—how does one learn practical functional programming? What problem sets do you work through to get the needed practice? I suppose the question can apply to learning any new language, but there is much paradigm carry-over between imperative languages (and probably between functional languages). Are there certain problems that will aid that paradigm shift? If you feel like you’ve developed functional chops, in any functional language, I’d like to hear in the comments how you got there, what you’d change in retrospect, and your advice for me and others like me.