2 - Dowload clojure.jar
as a shorthand for
2.1 - Install Maven
2.2 - Install git
2.3 - Clone https://github.com/clojure/clojure.git
2.4 - Run mvn -Plocal -Dmaven.test.skip=true package
I've inherited code bases in different languages in the past, and generally, it's the unfamiliarity to the language that makes it harder. Especially Clojure, being so different, the unfamiliarity is even stronger.
For example, if you read the Clojure source code (https://github.com/clojure/clojure) are you similarly lost? Or when reading any random Clojure github project?
Also, is this the first time you inherit software like that? Like have you ever inherited other similarly complex piece of code in your main language? Because I have as well, and it is never easy, no matter the language and familiarity.
Not trying to attack you by the way, it may be true, but I'm trying to isolate the variable of it being written in Clojure against the rest to really get a feel of the effect Clojure has over what you are experiencing.
Rich has a fairly strict development approach and wants to personally review and approve all changes to the core. There are complaints about that process, and that's fair. But as far as I have seen, most large, successful projects have similar personalities leading them (Stallman, Linus, Larry Wall, Guido...).
Finally, I should add -- if what you are looking for is software freedom... then you should absolutely consider using a Lisp like clojure. Lisp's give you the power to control your language through macros and non-core libraries. Unlike other languages, you do not need a core development team to make language changes for you. Perhaps this is why clojure is so powerful... because the core process issues you have heard about are not actually that important, and in fact the language itself enables substantially more software freedom than perhaps you are giving it credit for.
git clone https://github.com/clojure/clojure.git
cd clojure
mvn -Plocal -Dmaven.test.skip=true package
At least three:
- Clojure on the JVM: https://github.com/clojure/clojure
- ClojureScript (JavaScript): https://github.com/clojure/clojurescript
- Clojure on the CLR: https://github.com/clojure/clojure-clr
- CL has been around so long, there are TONS of good books and online documentation. Clojure literature is just starting out, really
- Clojure places a strong emphasis on functional programming. I have no doubt that this was the right decision, but trying to wrap your head around Lisp AND FP at the same time is... well... I hope you have plenty of headache medication because your brain's gonna hurt. CL is at home in the imperative and OOP style, so you can get your Lisp on first, then get hip to the functional jive. A good thing about all Lisps though is that you naturally end up writing most things in a functional style anyway. It just kinda happens.
- It's a bit unsettling to learn lisp by learning Clojure if you still have a bad taste in your mouth when it comes to Java. When you use CL, you know you're on a pure Lisp platform, so when it comes time to learn Clojure you'll just "know" when you're doing something in idiomatic Clojure/Lisp vs punting to Java.
- Clojure has more native data structures than Common Lisp (by that I just mean more homoiconic data structures, I'm aware that CL actually has arrays and hashtables and such). This is much better, IMO, from a practical perspective, but might get in the way when you're trying to grok the philosophical purity of Lisp.
So my advice is to start with Common Lisp and then move to Clojure. Specifically:
1. Read "Land of Lisp" (http://landoflisp.com/). It's a gentle introduction to Lisp and it's fun.
2. Read "Practical Common Lisp" (http://www.gigamonkeys.com/book/) and have fun with the "practicals". I really love this book because you build kind of "real stuff" and it helps tie all the concepts together.
3. Read and try to understand pg's "On Lisp" (http://www.paulgraham.com/onlisp.html). It gives you a much better take on what makes Lisps so much more powerful than other programming languages.
4. Watch Rich Hickey's talks on blip.tv (http://blip.tv/clojure). I would recommend watching the "Clojure for Java Programmers" talks first, then the "Clojure for Lisp Programmers". You'll need to budget about 5 - 6 hrs to watch all four videos. You probably don't want to watch the latter until you know things like what a Lisp-1 is vs a Lisp-2, what "homoiconic" means, and the difference between a macro and a reader macro. I'm not saying you need that knowledge specifically for the talk, just that if you know what those all mean then there's a good chance you'll get a lot of value out of the talk.
5. Install Clojure and play around with it. I liked trying to port the stuff from Land of Lisp and Practical Common Lisp to Clojure as it got me on firm footing quickly. For the former, take a look at this StackOverflow post: (http://stackoverflow.com/questions/5363393/rewriting-wizard-...) to get started. Then, head over to PCL->Clojure (http://thinkrelevance.com/blog/2008/09/16/pcl-clojure.html) for help in converting the CL practicals over to Clojure.
6. Get idiomatic by reading good Clojure code. I recommend the [Clojure source](https://github.com/clojure/clojure) itself as well as Compojure (https://github.com/weavejester/compojure) to get started.
Finally, a note on development environments: just use whatever works for you. I prefer Emacs, but note that getting Clojure working well with Emacs is slightly more difficult than getting CL working well with Emacs. This is mainly because you can run into dependency issues and out of date packages fairly easily. However, if you get Emacs up and running with Common Lisp through SLIME (http://common-lisp.net/project/slime/) and enable paredit (http://www.emacswiki.org/emacs/ParEdit) and all that good stuff, you'll have almost zero learning curve developing Clojure in Emacs using swank-clojure (https://github.com/technomancy/swank-clojure).
If you just want to play around with Clojure quickly and still have SOME semblance of an IDE that understands Lisp, try clooj (https://github.com/arthuredelstein/clooj). It's a bit bland on the looks side and low on features, but it gives you parenthesis matching and a nice REPL so it's a good way to play around with Clojure without feeling committed.