Recommended Reading : Into Orbit with Clojure – An Excellent Example

Periodically you run across an excellent site that provides a wonderful explanation and exposition of a computer language.  I recently ran into this excellent and well-constructed example of building an application in Clojure.


If you haven’t seen this site it is well worth looking all the other Clojure-related tutorials.


clojureiconGo to more posts on clojure or that are clojure-related at

Recommended : Reflections on a Real-World Clojure Application (Devoxx UK 2013)

Excellent presentation by Malcolm Sparks that covers real-world Clojure applications. The discussions provides a nice comparison with Java. It specifically offers an healthy discussions about immutability/mutability variables within a language and the  getter/setter method aspect of Java.  He then moves on to discussing and explaining Clojure’s syntax and features.


clojureiconGo to more posts on clojure or that are clojure-related at

Recommended Viewing : Clojure at an Investment Bank

In looking at use-cases, the topic of Clojure at financial institutions seems to be a recurring question. Anecdotal or rumored reports of a number of Clojure projects at financial institutions are discussed in various online groups.  This post covers a real investment bank project. In this video presentation, work on a large scale UBS application is covered.

More on this here.


clojureiconGo to more posts on clojure or that are clojure-related at

Recommended Viewing : Clojure in the Large (Patterns & Anti-Patterns)

Stuart Sierra of Relavance provided an excellent presentation that shared patterns and techniques around large scale Clojure deployments.


This nicely encapsulates a lot of pattern/anti-pattern into a nice presentation.

A great resource that you may find useful is the Clojure Toolbox.


clojureiconGo to more posts on clojure or that are clojure-related at

Learning: Land of LISP + Hilarious LISP Video and Cartoon


Land Of LISP site

On the heels of my previous post , It’s 2014 and LISP Is Seeing Increased Adoption, on the surprising and increasing adoption of LISP by companies, I discovered a hilarious video that I just have to share. Before I do that, some context.  I had run into some ‘Code as Art’ videos where LISPers were on-the-fly creating music as they coded. More about that on a different day.  I bumped into this video.  The focus of this video is around a book, Land of LISP, written to teach LISP concepts through gave development in the language.  The video absolutely is hilarious but the accompanying  cartoon makes it even more humorous. If you select the image on the right – it will take you to the book’s site where you can be entertained by a humorous video and cartoon that only geeks will truly appreciate. I have provided the youtube video below as well – for your entertainment.


Recommended Reading : It’s 2014 And LISP Is Seeing Increased Adoption

This is part 1 of a two part post.  LISP has seen increasing usage. For many of us like Java developers, some of us tend to look at LISP as an ancient language from the days of seriously funded computer science and basic science where AI projects could find funding from DARPA or other places (well, that was a long time ago when we spent actual dollars on science). Today many of us tend to think that LISP has disappeared. Not so quick. It has been having a sort of renaissance, in some cases by sitting on top of the Java VM.

The title of this post could have been ‘Is LISP Relevant in 2014’ ? Except the answer is becoming too obvious. On Tiobe Programming Language list, LISP is now in the top 20 languages. It’s unclear whether that includes Clojure and Common LISP.   While I was waiting for the latest build of Steel Bank Common LISP to complete I spent some time  thinking about the fortunes of LISP in today’s world dominated by Java, C, C++, PHP, Python, C# and Objective-C.  Is LISP still relevant ? I had roughly 28 minutes to dwell on this given my constraint.


Remembering back to the number of AI Winters that have occurred and noting that LISP was one of the two languages (the other was Prolog) that had the misfortune to be so closely tied to numerous AI projects during those times – it certainly was effected effected adversely by this connection.  LISP Machines of the 1980s from Symbolics and TI took a fatal hit when engineering workstations were introduced and these systems could run LISP implementations.  The result was that the much more sophisticated and specialized LISP machines fell victim to market economics.  The emphasis became less about AI and aiming at a DARPA marketplace and more about applications (including expert systems, image recognition, etc) that could be written in more popular languages (C/C++, Java, etc).  For the LISP world this was a big loss. Sophisticated LISP machines with LISP-tuned class browsers, debuggers disappeared off the landscape – replaced by more general-purpose systems.  Was it a loss ?  If you had ever worked on or compared LISP machines to workstations of the time the answer is quite simply – yes.  From a LISP-cost perspective you would expect LISP on general-purpose hardware to be a win. Reality was slightly more complicated.

Symbolics3650At the time LISP was closely tied to AI efforts that were viewed as not being successful – this should be looked at in context. All of this had highly inflated expectations. Consider one book in particularly as the poster child for why expectations were set so high – The Fifth Generation Project.  Other languages at the time, such as Ada, C/C++, and much later Java would go on to capture the buzz, imagination and with it the oxygen that sustains the software developer community. A number  of projects that you might expect to use LISP adopted Java – DROOLS and CYC are two examples.  And yet Java like C/C++ is less than ideal  for writing inference engines or “list-based” rule engines or applications that are ill-defined from the very beginning.  The author of Successful LISP has written some nice points about why LISP sees objections.  One big one is that – other languages like Java, C, C++, etc are more like each other than LISP. The lack of orientation and familiarity with other languages makes LISP remarkably unfamiliar to most developers.

However, the good news is that there are a number of LISP implementations and some sit on-top of the Java platform and are able to make use of not only LISP but also the underlying Java classes. So not only has LISP survived but there are a small number of commercial LISP implementations from companies that have been in the market a long time.  There are a larger number of open source implementations.  Specialized and sophisticated LISP machines are dead, the age of LISP machines (in more generic sense)  is not totally behind us – the average popular Intel-based desktop or server is capable of running LISP-based software.  A key point is that like other languages – modern, increasingly faster processors, larger memory configuration and much faster storage have been a benefit to running LISP software.

So it’s a complex answer, followed by a second question – does anyone use LISP ?  If we clojure03look at the dialects of LISP – Common LISP, Scheme, Clojure, etc. The answer is simply – yes, people are using LISP.  Common LISP is being used in an number of interesting settings, for example it is being used at  financial institutions.  Other versions of LISP, like AutoLISP, are shipping in AutoCAD products. The recent rise of Clojure, a version of LISP,  should be an indicator that there is not only interest but there are companies using LISP in their  deployments. You can see some of the companies that use Clojure at their success stories site. A partial list of who is using Clojure can be found in the discussion groups. Just Clojure alone has a fairly large following. Some of these are large financial institutions, others Twitter and Amazon suggest that Clojure’s uses is not aimed at a niche area. Quite the opposite, far from being dead – Clojure and the  LISP-based languages have dramatically expanded the language’s use.  Surprised ? This is contrary to the myth that the language is no longer used.  Clojure and Common LISP are actually expanding their developer bases.  LISP usage, as result is actually growing.  Really? Yes, Really. It doesn’t take a wizard to see that when startup companies  decide to use Clojure over, say, Java – that indicates LISP usage is growing.  In this case, Java also benefits by serving as the lower-level virtual machine (JVM) that Clojure runs on.

So why has LISP not seen the fate of other extinct languages like Algol ?  Consider there have been attempts to re-create some of the features in LISP by creating other languages – Haskell comes to mind (that’s not a criticism of the good work the Haskell community has done).  LISP persists because it is relevant. It contains a notion that code is data and that has made it a compelling language. The amount of syntax in LISP is almost none.  I leave you with the compelling rationale from Clojure’s site.


The LISP community is seeing a resurgence in tools – an interesting recent addition to the Common LISP toolset is QuickLISP which is a library manager for Common LISP and hosts over 900 libraries. There is a great community Common LISP resource that further demonstrates the ecosystem.  There are a number of LISP conferences every year, one example.


Clojure has had numerous conferences. You get a taste for what is going on in the Clojure community by looking at the content from those conferences.



Lots of interesting talks/slides from this conference. Innovative and interesting attempts at shifting how we view databases – you can download the slides from here. I’ve posted  about Datomic previously. At the heart of this database is Clojure.


Further, Clojure has a scripting language, called ClojureScript. Here is a nice video on production Clojure.

You can clearly see that Clojure – is having an effect on how companies deploy applications and services. It is mystifying too many C/C++ and Java developers that this could be the case.  It is not so strange.  There are a number of things these languages can learn from Clojure.


Finally an interesting comparison by Peter Norvig can be found here.  It is worth noting that for some of us, LISP seems like an ancient language. It is not.  Reality is LISP has evolved nicely and has a number of implementations and it is seeing increased usage. So yes, here we are in 2014, and LISP is not only still with us, but it is gaining traction and it is highly relevant.

clojureiconGo to more posts on clojure or that are clojure-related at