Advantage of Learning Lisp for a Python Programmer

I think the biggest advantage of learning Lisp, ML or Haskell for a Python programmer is the appreciation of thinking recursively for algorithmic problems, separation of mutable and immutable states, the importance of deterministic output types, the problems of type coercion, and a familiarity of basic functional programming building blocks such as lambda, accumulate, zip, map, reduce, filter, currying, higher-order functions, partial functions, streaming, eager and lazy evaluation and so on. They are immensely useful for writing concise code snippets. They may not be the ideal modeling blocks for every programming problems, but for data processing, they are far better substitutes for pure procedural code. If you pick a statically typed functional language like SML or Haskell, you'll learn all the elaborate ways to assemble a program from a bunch of functions with the right types, and the magic behind type inference.

Functional programming is a kind of enlightenment. Learning functional programming not only makes you a better Python programmer, but also a better programmer in general. As a final bonus, learning a functional language will make you understand why the BDFL made the choices he made in Python. Granted, GvR denied that he cares about FP in Python, but undoubtedly he knows enough of it that a lot of its concepts have seeped in. List-comprehension is a great example of it.

So, are there any advantages of learning Clojure after Python in the way I can write programs?

Compared to Python, Clojure focuses on a more functional approach. It is not as rigidly as Haskell enforcing referential integrity, but strongly encourages functional programming, and thus is a good choice for introducing you to a generally more functional style. Unlike Haskell, it is not a pure functional language in the strict sense, as there are means of altering mutable state, and you are not forced to separate side effecting from pure code, although this is widely considered good style. Clojure provides efficient persistent lazy datastructures supporting this.

My impression is, that Guido is not really a friend of functional programming, and that he and the Python community simply made other design choices. That does not make Python a lesser language, but a rather different, more "conventional" one. So you will discover other and very powerful means of abstraction and composition, as well as other algorithmic approaches in languages like Clojure or Haskell -- a different view on programming. (For example a shift of focus to transformations of data using different higher order functions, function composition and so on. This is also possible in Python, being a modern language that incorporates some of these features, but functional languages take it to another level.)

As far as other Lisps are concerned: Clojure is more oriented towards functional programming than most Lisps in use today. Although they are among the oldest functional programming languages, it is not true that Lisps in general discourage imperative programming. CL for example is a very eclectic language, which will allow you to program in a variety of paradigms -- It has a very elaborated OOP-System (CLOS), to mention just one.

Apart from the functional programming aspect, you will also learn about the benefits of homoiconic languages and a fully featured Lisp macro system. There are very few languages which treat code as data and allow, to this extent, forging the language (thus DSLs) at your hearts content. The point here is not only that this is possible, but that it is made as easy as possible. So, even if Haskell might be the better choice for learning about functional programming (of course this also depends on taste), Clojure has the additional benefit of being in the Lisp family of programmable programming languages.

Those are the two major points you are going to learn about, coming from Python to Clojure.

Clojure also heavily focuses on parallel/concurrent programming. On one hand, this is a feature shared by functional languages in general, because eschewing mutable state means avoiding one big source of bugs in such programs. On the other hand, Clojure was specifically designed to make concurrent programming easy.

Another important difference between Clojure and Haskell is Clojure's -- not only as far as typing is concerned -- more dynamic approach to programming. (That is true for all Lisp dialects I know.) At the moment, I am more fond of Haskell, and really appreciating its impressive type system, but I would say that you could really benefit from Clojure as a means to widen your horizon. There are different approaches to programming, and learning about them will definitely make you a more rounded programmer.

James Gosling put it very well in http://nighthacks.com/roller/jag/entry/equations_and_methods in talking about optimization.

So what is Newton's Method? It's kind of like a function that takes two functions as parameters (f(x) and f'(x)). But the second parameter is should really be derived from the first. f'(x) can be approximated by a little numerical trickery, but it's a numerically dicey thing to do. One of the big drawbacks with closures and function pointers is that you just get to execute the function. You can't do any introspection. This is one of those times where I miss Lisp macros: the ability to rip open a function and do wild things like symbolic differentiation was wonderful. My PhD thesis project was filled with such hackery.

The problem is that you need both the function and the first derivative. In most languages you can only execute the code, but in Lisp you can treat the code as data, and find out what it does, and do the symbolic differentiation yourself.

See the difference?

Some ideas:

• Master concurrency using Clojure's persistent data structures and STM-managed references. See this video by Rich Hickey. In my view, this is possibly the most exciting feature of Clojure as it offers a credible route to building highly concurrent applications for multi-core machines that are free from locking issues.

• Exploit the fact that Clojure is a homoiconic language (as are all Lisps) and you can therefore treat code-as-data. To see the power of this, try writing some macros that generate Clojure code at compile-time..... you can use this to generate your own syntax and language constructs which is much more powerful than most other languages. Try implementing a proper short-circuiting "and" operation as a function call, for example - in most languages you can't because the arguments will both get evaluated before the call to "and". But with macros this is easy.

• Write some non-trivial code in a functional programming style. Coming from any imperative or OOP background this should be a good experience. e.g. use Ring to write a web server as a single function..... see this great video for inspiration.

• Read SICP and do the exercises in Clojure (it's not particularly hard and a good mental exercise to translate the examples from Scheme to Clojure). This book is a masterpiece of MIT computer science education and will certainly broaden your mind if you haven't explored these kinds of concepts before. There is also a "SICP in Clojure" project that you can google although I'm not sure how complete that is so far.

• Have fun with lazy evaluation. Write some algorithms using infinitely large data structures. Project Euler has quite a few challenges that are quite amenable to this kind of approach (e.g. creating a lazy list of all prime numbers.....)

its a zen thing...

see that code is data, and data can be code even when you may not want it to ;) see that code can create data can create code, and learn to type in abstract-syntax-trees :)

If you want a different style, try something that promotes/restricts you to using functional constructs, rather than something that just supports those constructs.