Lambda the Ultimate

See the Dusty Decks announcement.

Computerworld is undertaking a series of investigations into the most widely-used programming languages.

• Ada - S. Tucker Taft
• Arduino - Tom Igoe
• ASP.NET - Microsoft
• AWK - Alfred V. Aho
• AWK - Brian Kernighan
• Bash - Chet Ramey
• Bourne Shell - Steve Bourne
• C# - Anders Hejlsberg
• C++ - Bjarne Stroustrup
• Clojure - Rich Hickey
• ColdFusion - Jeremy Allaire
• D - Walter Bright
• Erlang - Joe Armstrong
• F# - Don Syme
• Falcon - Giancarlo Niccolai
• Forth - Charles Moore
• Groovy - Guillaume Laforge
• Haskell - Simon Peyton Jones
• INTERCAL - Don Wood
• JavaScript - Brendan Eich
• Lua - Roberto Ierusalimschy
• MATLAB - Cleve Moler
• Modula-3 - Luca Cardelli
• Objective C - Brad Cox
• Perl - Larry Wall
• Python - Guido van Rossum
• Scala - Martin Odersky
• Tcl- John Ousterhout
• YACC - Stephen C. Johnson

TileStack is an attempt to resurrect HyperCard and bring it to the web.

Running online there are going to be limitations about which stacks can be ported, which may reduce the usefulness and impact of this project, but maybe a standalone version will come later.

The system compiles Speak (the TileStack version of HyperTalk) to Javascript. If the result is not obfuscated, something I haven't verified, it may be possible to augment the output from TileStack with additional capabilities not supported or not yet implemented.

From the compatibility angle it is interesting to note that they renamed the language and seem to imply they are going to extend it beyond HyperTalk, without giving any specific guarantee about future compatibility. I'd suggest releasing the compiler that's as close to full HyperTalk compatibility as a separate product (or even, if they can bring themselves to do it, releasing it as open source).

A History of Erlang and the accompanying Presentation Slides by Joe Armstrong are a must read for anyone interested in PL history.

Erlang was designed for writing concurrent programs that "run forever". Erlang uses concurrent processes to structure the program. These processes have no shared memory and communicate by asynchronous message passing. Erlang processes are lightweight and belong to the language and not the operating system. Erlang has mechanisms to allow programs to change code "on the fly" so that programs can evolve and change as they run. These mechanisms simplify the construction of software for implementing non-stop systems.

(Link to previous HOPL-III papers on LtU).

Carl Hewitt is speaking tomorrow at Stanford's CSLI CogLunch on the history of logic programming.

A paper is here, so LtU readers can offer their perspectives on the argument.

[Chicken-users] macro systems and chicken (long), Alex Shinn, Apr 2008.

There seems to be a lot of confusion in the Chicken
community, and the Lisp community in general, about the
different macro systems, so I thought provide some
background information and discussion of the eggs available
in Chicken and their uses.

A very nice post that provides a historical overview and implementations of a hygienic (swap! a b) macro in different macro systems: syntactic closures, reverse syntactic closures, explicit renaming, syntax-case, and syntax-rules.

I didn't know syntactic closures before, and find their interface and implementation simple and easy to understand. Any reasons why they aren't used more in Scheme?

Back in 2003, Martin Berger conducted a fairly lengthy interview with Robin Milner. The transcript includes some interesting tidbits on the development of ML, CCS, and the pi-calculus. Among other things, you'll find a recounting of how Milner and David Park came up with the idea of bisimulation, a discussion of the rationale behind some of the design decisions Milner and his colleagues made in creating the pi-calculus, and Milner's thoughts on how theory should influence programming languages:

I do care that languages should be informed by theories...I actually think the best way forward for us now is to look at concurrent calculi as modelling theories for modelling interactions, whether they occur in programs or in outside programs...Languages should emerge from that. They should be treated as a part of a modelling theory. Up to now I don't think we had sufficient incentive to make sure that our languages are close to scientific models. It's only with the onset of computation as a global phenomenon that modelling those interactions becomes so scientifically important that it is bound to have its effect on programming languages.

From the introduction:

Seen in outline, the history of LC and CL splits into three main periods: first, several years of intensive and very fruitful study in the 1920s and ’30s; next, a middle period of nearly 30 years of relative quiet; then in the late 1960s an upsurge of activity stimulated by developments in higher-order function theory, by connections with programming languages, and by new technical discoveries. The fruits of the first period included the first-ever proof that predicate logic is undecidable. The results of the second attracted very little non-specialist interest, but included completeness, cut-elimination and standardization theorems (for example) that found many uses later. The achievements of the third, from the 1960s onward, included constructions and analyses of models, development of polymorphic type systems, deep analyses of the reduction process, and many others probably well known to the reader. The high level of activity of this period continues today.

Beware: This is a long paper (but less than you might expect it to be by looking at the page count: about half the pages are dedicated to the bibliography).

In the announcement on the TYPES Forum the authors invited comments, suggestions and additional information on the topics of the paper, namely the development of lambda-calculi and combinatory logic from the prehistory (Frege, Peano and Russell) to the end of 20th century.

Paul McJones alerts us that the ACM posted PDF versions of some books in its Classic Books Series, which are available to anyone who creates a free ACM Web Account.

Among the currently available books, LtU readers are likely to be particularly interested in Hoare and Jones's Essays in computing science, Adele Goldberg and David Robson's Smalltalk-80: the language and its implementation, and Dahl, Dijkstra, and Hoare's Structured programming.

Long time readers will also know that I highly recommend Papert's Mindstorms: children, computers, and powerful ideas to anyone interested with the effect computers might have on education. Papert's Logo remains to this day the best children oriented programming language, but even if you disagree with me about this, his book is a must read.

Lemonodor has the story, and the links, starting with Dan Weinreb's blog post. Yes, Dan Weinreb has a blog, so if you weren't paying attention, now is the time to check it out!

For me, the take home message is from Paul Graham: If the Lisp machines were so gratuitously, baroquely complex, I should really find the time to learn more about them...

Happy new year, everyone!