Tag Archives: LISP

Is Groovy back in fashion?


Last year I was taught “Object Orientated Design and Programming” as part of my Birkbeck MSc, using Groovy, a dynamic functional language built on top of Java and running on the Java VM.

I enjoyed it and liked Groovy – I went on to write some pieces of software for my MSc project using it.

But it also gave the impression of being a dying language and there were some complaints from fellow students who thought C# or Java itself would have been a better bet for them jobs wise (to which one of the lecturers responded with admirable chutzpah with a suggestion of using Lisp in the future).

This last week I have again been dabbling in Groovy and I get a sense that the language is suddenly back in fashion and its community of users seems more energy charged than a year ago.

Nothing scientific to back that feeling up with, just my judgement.

John McCarthy


John McCarthy, an American computer scientist.
Image via Wikipedia

October 2011 has not proved to be a good month for computer pioneers, and the death of John McCarthy, so soon after that of Dennis Ritchie means we have lost two of the most significant and influential of all.

McCarthy was the designer of LISP which, with FORTRAN, holds the record of the oldest living high level computer language. LISP is the grandparent of today’s functional computer languages and still has many fanatical supporters in its own right.

(Scheme is the LISP dialect used in Structure and Interpretation of Computer Programs – a book I am currently re-reading.)

Like Ritchie, though, it would be wrong to single out McCarthy for only one achievement: because it neglects the rest, such as his pioneering work on artificial intelligence (his own term) and his formulation of the concept we now know as cloud computing.

My first R program


Having used Groovy (which makes the scripting environment feel familiar) and some Scheme (via Structure and Interpretation of Computer Programs), R does feel completely alien, but it still feels like a steep learning curve.

But here’s my short script -

unpatched <- read.csv("~/unpatched.txt")
unpatchcons <- transform(unpatched, realm=realm*60 + reals)
attach(unpatchcons)
linelog<-lm(realm~size)
plot(size, realm, log="y")
abline(reg=linelog, untf=TRUE, col="blue",lty=3)
detach(unpatchcons)

And here’s the graph (of Linux kernel compile times) it generates – the blue line is obviously a very bad fit!

Linux kernel compile times

Coming up… the lambda calculus


An example of a DFA state diagram
Image via Wikipedia

Another thing that The Annotated Turing taught me is what all those lambdas that I have seen over the last 25 years were about, or at least it introduced me to what they were about.

So I have just ordered a copy of Structure and Interpretation of Computer Programs: and I can guess that some blog posts will eventually follow.

Oh no. Maybe I am turning into a LISP hacker – having finally reached the age that all these guys were when I first became aware of them (older, actually).