And that would be a BIG mistake. Your clojure-using peers will be knowledgeable engineers with things to do and products to ship and very little time to help you. There is also zero academic literature to hold your hand. With a new programming language, you are often forced to reach out to your own past experience for a repertoire of programming techniques. You will learn the syntax of clojure, sure, but you will be writing whatever languages you know now in a fully parenthesized prefix syntax.
A better question to ask would be "what language motivated Rich Hickey to create Clojure"; pick a more stable Lisp, learn the ropes, and come back to kickass on the JVM in a few months.
I see no reason to spend a lot of time learning Common Lisp at this point. The Clojure community is helpful, because everyone is so excited to have a Lisp they can really use. Stuart Halloway's book is a good enough introduction to Lisp concepts that one could go on to the more academic books to learn more. The book consistently takes pains to show idiomatic Clojure--a good first step away from the Java/C/C++ mindset. The core syntax of Clojure has been stable for several months now, and the implementation itself has been stable for much longer.
Learning Scheme just to read SICP (for instance) isn't necessary either. Since Clojure is a Lisp-1, it works well for the exercises in a Scheme-based book.
I will not argue the merits of CL since I would be biased, but Scheme? Clojure is no scheme. It can barely do tail recursion cleanly without resorting to a keyword (recur?)
Scheme, along with Mozart/OZ are the perfect candidates for delivering programming skills without platform obstruction. Admittedly, it would take an specific implementation Scheme, a large and feature-rich one, to properly introduce someone to the real powers of Lisp.
Go thorough a series of complete Lisp systems, say MIT Scheme and CMUCL, and see what a complete Lisp system looks like.
I've been on #clojure and asked stupid questions more than a few times. I've always gotten very well thought-out answers, and everyone has always been friendly.
i totally don't agree with that. Clojure enforces a much more functional style "by default" than any other lisp i know of (not that i am a vet lisper).
I for once understood lisp with clojure and scheme 1 year ago. Now i can do Common lisp, but playing with clojure was much more enlightening. If you ask me why, i'd say that it's a mix between good timing (i had been reading about lisp since a lot of time) and the fact that it's motivating to learn on a new platform with access to a ton of libraries.
My advice though : Don't start with common lisp. Most of the ressources for learning it are really unclear (PCL included)
Start with Scheme (lots of good newbie-oriented ressources), and then switch to clojure once you grasped the basics.
Good point. However, using a guide such as Programming Clojure from the Pragmatic Bookshelf is a pretty quick way to try out some of the 'Lispy' concepts. I'm literally beginning the book so cannot comment further but it seems an accessible way to begin.
You would be missing on classics of the field: Norvig's PAIP, PG's On Lisp, Quinnec's Lisp in Small Pieces, and, of course, SICP.
Lisp is a language best "learned" furiously, through different dialects, implementations, extensions and library packages, and of course, thorough own implementation.
Clojure hasn't undergone the same vetting other dialects have gone thorough. Reading Common Lisp the Language (2nd Ed.) you will truly see what it takes to add a feature to a language and what it takes to remove it. 20+ people had to convince each other why something was worth keeping :-) And from there read the specs for ISLisp, EuLisp and and LeLisp. Schemes implementations have been a treasure trove of pure human genius: one implementation, T, has been responsible for so much it merits a year of your life just to read the associated literature and follow the heritage of this beautiful language.
Clojure has Rich Hickey's video, but none of it is, yet, time tested. A fine Lisp, no doubt, just not one for active learning.
Appreciate the comment, this is why I come here :).
I've been meaning to- and will, read PG's On Lisp. I saw the benefit in starting with Clojure being: the setup (basically nothing if you have a JVM installed) and the fact that applications created can be deployed in a JVM container- making it possible you any projects you'd like to host.
Your comment has inspired me to look into some of the schemes at least at the same time. Thanks.
Save this paper and read it a year or two into your Lisp hacking:
www.dreamsongs.com/Files/HOPL2-Uncut.pdf
Once you know your Lisp, that paper will immerse you into the culture and history you need to become a bona fide Smug Lisp Weenie.
Lisp is not just a language, it's an ongoing and animated debate. Get your feet wet, get emacs and Slime, play around with all the dialects and implementations it supports, hack the good hack, send patches, ask for help, start a company, and welcome to the community! :-)
On Lisp is a must, it is just a really brilliant book that delves into what Graham argues (and I accept) is the most distinct and powerful feature of Lisp, macros.
I can see evidence that Clojure contributors have read it too, just the other day there was an example of an anaphoric macro posted on the mailing list. Very cool.
A better question to ask would be "what language motivated Rich Hickey to create Clojure"; pick a more stable Lisp, learn the ropes, and come back to kickass on the JVM in a few months.