The reality, unfortunately, is that in the modern, commercial, software development environment, Lisp and SmallTalk are pretty much irrelevant.

The buzz goes to Java’s, Ruby’s, and — to a lesser extent these days — Python’s oft [sometimes poor] wheel reinvention, with C# rising and the various functional languages off in a corner making a lot of noise banging their immutable sticks together.

Of course, many of us Objective-C developers froth at the mouth when the Java kids claim that Obj-C is just a weirdass derivative of Java when the exact opposite is true! Then the SmallTalkers crawl out of the wood work and ask us to pipe down, get off their damned lawn, and come back when Objective-C can redefine true to false.

Meanwhile, the Lisp and SmallTalkers all rage about Been There, Done That, Wake me when you have something new.

Of course, if you want to go all hippie on it, [Lisp and the] Art of the Metaobject Protocol must be mentioned.

Lambda limit’s people’s perception? “Lambda: The Ultimate ” – that lambda? If Python’s totally broken closures are to blame for this, GvR ought to have actually removed them and spared us all the trouble.

“Blocks didn’t seem to carry quite so much comp-sci preconceived baggage.”

I guess being a Lisper is a bit like being a groundhog. Every year, you stick your head out, sniff around, check the blogs, and figure we’re all in for another year of ignorance and stupidity. Wake me up again next year and I’ll tell you whether or not we’ve caught up with where programming language research was in 1980. Probably not, as long as comp-sci is “preconceived baggage”.

I’m not saying that “block” is an indefensible choice of name – in fact it was probably the best choice in the specific context of Objective C given its Smalltalk heritage. But this line of argument induces Hulk rage in me. The same circular we-can’t-do-anything-too-academicish reasoning is why we’re all circling the drain of the ’70s over and over again.

(Actually that’s not quite fair: Microsoft seems to be dragging everyone headlong into the 1990s with F#. It’s really Apple who’s behind the times here.)

Lambdas are most often associated with capturing an expression, often to be used as a filter on a collection. In Python, a lambda is truly one single simple expression. The proposed lambdas in C++ are effectively a compile time only expression oriented feature.

Blocks are designed to capture both simple expressions for the purpose of collection filtration, callback bindings, etc… as many of the APIs in Snow Leopard demonstrate. However, they are also designed to capture full units of work in the form of entire chunks of code. That is, a Block is often a chunk of code that one might normally find as the implementation of a method or a function.

Thus, the label lambda and closure were rejected because they seemed to limit people’s perception of what the feature was capable of or how it could be appropriately used. Blocks didn’t seem to carry quite so much comp-sci preconceived baggage.

Blocks also implies “building blocks” and it is quickly becoming the case that many modern Cocoa applications are composed of a bunch of Blocks that do work concurrently via GCD.

Folks have ported it to Leopard (Tiger shouldn’t be hard) and the iPhone.

See: http://www.plausiblelabs.com/blog/?p=8