Hacker News Reader

Comment by ganarajpr | Hacker News Reader

Can some of the clojure and clojurescript gurus take some time to write beginner friendly, hand holding tutorials? I mean, I can see the power of these technologies but the very thought of climbing a learning curve AS WELL AS a getting started curve ( that too without any external help! ) is the single most important thing that turns people off.. especially me. My general complaint is with regard to how many tutorials and even books are out there on these topics! Countable, with the fingers in one hand perhaps!

View on HN

Discoverability is a problem, but the Clojurewerkz people are top-notch (http://clojurewerkz.org/). These are helpful:

* Intro: http://clojure-doc.org/

* Libs: http://www.clojure-toolbox.com/

* Examples: http://clojuredocs.org/quickref/Clojure%20Core

* Pedestal: https://github.com/pedestal/app-tutorial

Also a few books at different levels:

* http://www.clojurebook.com/

* https://leanpub.com/fp-oo

* (2nd ed early access available) http://joyofclojure.com/

* http://pragprog.com/book/shcloj2/programming-clojure

* http://www.manning.com/rathore2/

* http://www.packtpub.com/clojure-data-analysis-cookbook/book

Clojurescript book from oreilly, http://shop.oreilly.com/product/0636920025139.do

(On the whole, a really excellent set of books for the language)

I would also mention following tutorial on CLJS: https://github.com/magomimmo/modern-cljs

If you're referring to core.async specifically, keep in mind it's very new. Its readme[1] goes as far as to say, "This library is work-in-progress, experimental, broken etc. It should only be used by people working on it, ATM." With more maturity will surely come more examples and tutorials.

But if you mean Clojure(Script) in general, I kind of agree. There are some beginner friendly tutorials; lately Andrew Brehaut's intro to the Clojure web stack[2] has been smooth going for me, despite being a bit dated. But you have to look around. In particular, I've found the small-scale mechanics of the language easy to pick up via Clojure Koans[3], 4clojure[4], and ClojureDocs[5]. What's missing the most IMHO is approachable introductions to the big-picture concepts. Especially the less generically lispy, more Clojure-specific parts, concerned with concurrency and state. (I hear the book Clojure Programming by Emerick et al. is good for that... have yet to read.)

I kind of understand Clojure not being easy or quick to learn, because powerful tools take time to master. But even with that said, it could be better. When I get confident with Clojure I hope to be part of a new wave of Clojurists who write really beginner-friendly tutorials :) I think it won't be the "gurus" who write them, but regular joes/janes like you and me for whom the initial difficulty of this stuff is still a fresh memory.

[1] https://github.com/clojure/core.async

[2] http://brehaut.net/blog/2011/ring_introduction

[3] https://github.com/functional-koans/clojure-koans

[4] http://4clojure.com/

[5] http://clojuredocs.org/

I looked at Clojure at one point and fell in love with the lispy but not too parenthetical syntax. I left it behind after a while because I couldn't deal with the awful exception tracebacks which were supremely unhelpful when debugging. Most of the more arcane messages had to do with fundamental syntax errors, which was probably not as big a deal for an experienced programmer. However, it made it very difficult for a bigger to debug when you couldn't so much as see the line number on which you made the mistake.

They may have fixed that recently, and this CSP implementation is really cool, so I may take a look back at the language.

I agree that the exception traces are pretty awful. Having used Clojure for a couple of years now, all I can say is that you do get used to them. Despite the complexity of the libraries and the 'foreign-ness' of the concepts coming from an imperative background, Clojure is fundamentally a simple language/environment.

I've developed a sense for the types of mistakes that I usually make and I tend to scan the stacktrace for my own namespace, ignoring the clojure.* lines[1]. Once I see what line caused the problem, if it's not a typo then it just takes less than a minute to reason about what's going on and find a solution. The REPL helps a lot, because you can make changes on the spot or try out a modified code fragment.

As some others have said here: yes, it is difficult to make the adjustment from an imperative way of thinking but it's really, really worth it once you get there.

[1] You can probably even de-emphasise clojure.lang stacktrace lines in Eclipse using the Grep Console plugin but I'm not sure about this off the top of my head, because the Eclipse console might override stderr output.

Oh, I'm familiar with functional programming. I had played around with Scheme for a bit before moving to Clojure and used Common Lisp and OCaml afterwards. It was always just the terrible stack traces and really long startup times that drove me away.

Reply on news.ycombinator.com