Lambda the Ultimate

The latest entry has Joe Armstrong discussing Erlang in the ongoing series of interviews with PL designers (The A-Z of Programming Languages). Two related things caught my eye. The first is the obvious truism about language features:

Removing stuff turns out to be painfully difficult. It's really easy to add features to a language, but almost impossibly difficult to remove things. In the early days we would happily add things to the language and remove them if they were a bad idea. Now removing things is almost impossible.

The other thing that I found intriguing was his mention of integrating version control into the language:

We have mechanisms that allow the application software to evolve, but not the language and libraries itself. We need mechanisms for revision control as part of the language itself. But I don't know how to do this. I've been thinking about this for a long time. Instead of having external revision control systems like Git or Subversion I'd like to see revision control and re-factoring built into the language itself with fine-grain mechanism for introspection and version control.

Not sure what he has in mind?

Forth Dimensions volumes 1-21, 1978-1999.

The Forth Interest Group's bi-monthly, hard-copy magazine with an international circulation was founded in 1978. The owner of one of Silicon Valley's most successful computer bookstores called it, "The best special-interest technical magazine ever". Forth Dimensions is no longer published.

The site contains scanned copies of every issue for download as PDF. Perhaps some Forth hackers can point us at the most interesting ones?

LtU Contributing Editor James Iry has written a brief history covering every prominent programming language and inventor:

A Brief, Incomplete ... History of Programming Languages

However, some of the details seem open to question. Perhaps LtU readers could help him iron out any historical inaccuracies.

For some inexplicable reason COBOL doesn't get much love from LtU. But COBOL turns 50 some time this year and we owe a tip of the hat to this venerable language behind so many large institutions.

The Guardian understands.

According to Michael Coughlan, a lecturer at the University of Limerick, one of Cobol's perceived drawbacks is its verbosity. But he reckons that's also one of its strengths. "It's not just a write-only language," he says. "You can come back years later and understand the code."

This opinion is shared by Mike Gilpin, of Forrester, who is an ex-Cobol programmer. "Cobol is one of the few languages written in the last 50 years that's readable and understandable," he says. And he's scathing about the readability of more fashionable languages, such as PHP and Java: "Modern programming languages are ridiculously hard to understand."

There you have it! More readable than PHP and Java. A ringing endorsement for the next half century.

An historic announcement by Simon Peyton-Jones:

Now that the logo issue finally has been settled, it is time to select the proper Haskell mascot. As you are no doubt aware, Microsoft's involvement in Haskell means that we have moved from avoiding success at all cost to actively marketing the language, and any language striving for success is entirely dependent on a cute and distinctive mascot. Where would Perl be today without its camel?

Since the recent logo discussion has demonstrated once and for all the
futility of attempting a democratic process in the Haskell community -
to be quite honest, the elected logo looks like an error message from an IBM
mainframe - I have decided to decide on a mascot myself.

So I hereby declare the official Haskell mascot to be the koala, in
the form of the image attached below. Please ensure that this image
accompanies any material published on the web or on paper.

The mentioned image can be viewed here.

A New Approach to the Functional Design of a Digital Computer by R. S. Barton, 1961.

The present methods of determining the functional design of computers are critically reviewed and a new approach proposed. This is illustrated by explaining, in abstracted form, part of the control organization of a new and different machine based, in part, on the ALGOL 60 language. The concepts of expression and procedure lead directly to the use of a Polish string program. A new arrangement of control registers results, which provides for automatic allocation of temporary storage within expressions and procedures, and a generalized subroutine linkage.

The simplicity and power of these notions suggests that there is much room for improvement in present machines and that more attention should be given to control functions new designs.

"One of the most amazing far reaching 4 page papers in our field" referenced in A Conversation with Alan Kay.

On December 9, 1968, Dr. Douglas C. Engelbart and the Augmentation Research Center (ARC) at Stanford Research Institute staged a 90-minute public multimedia demonstration at the Fall Joint Computer Conference in San Francisco. It was the world debut of personal and interactive computing: for the first time, the public saw a computer mouse, which controlled a networked computer system to demonstrate hypertext linking, real-time text editing, multiple windows with flexible view control, cathode display tubes, and shared-screen teleconferencing.

To commemorate this famous event, commonly known as the mother of all demos, SRI held a 40th anniversary celebration at Stanford today. As a small tribute to the innovative ideas that made up the demo, it is befitting to mention some of the programming languages that were used by Engelbart's team. A few were mentioned in passing in the event today, making me realize that they are not that widely known.

The Tree Meta Language was used for describing translators, which were produced by the Tree Meta compiler-compiler. MOL940 ("Machine Oriented Language" for the SDS 940) was an Algol-like high level language for system programming which allowed the programmer to switch to machine-level coding where necessary. Alas (and ironically), I have not found the primary documents about these languages online. Section IV of Engelbart's Study for the development of Human Augmentation Techniques gives an account of the language and tools that were used in the project, and includes an example giving the metalanguage description for part of the Control Language. Figure 8 in in this document is a useful overview of the system and the compilers and compiler compilers used to build it. The tech report Development of a Multidisplay, Time-Shared Computer Facility and Computer-Augmented Management-System Research (only the abstract of which is online) also mentions "four Special-Purpose Languages (SPL's), for high-level specification of user control functions" which sound intriguing. The tech report specifying MOL 940 is also apparently not available online.

If I understood what Andries van Dam said, the Language for Systems Development (LSD) developed at Brown, which targeted OS/360 and was based on PL/I, was influenced by the work of Engelbart's team. They were also claiming to have built the first (or one of the first) cross-compiler.

When asked about prior work that influenced them, SNOBOL was mentioned as an important influence. The influence the demo had on programming languages was manifested by having Alan Kay's talk conclude the event (he did not mention Smalltalk once in his talk, by the way, but it was mentioned a couple of times earlier in the day).

The When, Why and Why Not of the BETA Programming Language by Bent Bruun Kristensen, Ole Lehrmann Madsen, and Birger Møller-Pedersen from HOPL-III. BETA was an ambitious follow up to Simula - with orthogonality being a major design goal. The main things I found of interest are the attempts to create a unified abstraction pattern, the emphasis on modeling consistency between design and implementation, and the use of coroutines (ala Simula) for concurrency.

BETA is a programming language that has only one abstraction mechanism, the pattern, covering abstractions like record types, classes with methods, types with operations, methods, and functions. Specialization applies to patterns in general, thus providing a class/subclass mechanism for class patterns, a subtype mechanism for type patterns, and a specialization mechanism for methods and functions.

And while I'm at it, the original entry for HOPL-I on The Development of the SIMULA Languages by Kristen Nygaard and Ole-Johan Dahl is available (starts on page 3). SIMULA is one of a handful of most influential programming languages of all time. I found the following to be amusing:

In the spring of 1967 a new employee at the NCC in a very shocked voice told the switchboard operator: "Two men are fighting violently in front of the blackboard in the upstairs corridor. What shall we do?" The operator came out of her office, listened for a few seconds and then said: "Relax, it's only Dahl and Nygaard discussing SIMULA".

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

For those who like their PL History presented in avante guard beat poetry, a video of Steele & Gabriel's 50 in 50 speech at JAOO is made to order. Or as the link says:

A fun, artistic and enlightning presentation full of interesting facts - and who better to do it than Richard P. Gabriel and Guy L. Steele (the great Quux). Nothing more to say than the rallying cry; More cowbell!

Passing aside the Stephen Wright comic delivery of the two speakers, there are a lot of interesting thoughts, though very few are dwelled on. I think the most interesting things were the languages that they chose as expositions for the major ideas that they covered. Here's the ones that I picked out (though I ended up with only 49):

Do Loops	Fortran (Pascal,APL)	Guarded Commands	Algol-68
Array Origin	C, Fortan, Pascal, APL	Extensible Language	PPL
Domain Specific Language	APT	Structured Programming	BLISS, INTERCAL
Text vs. Environment	Algol-60, Lisp, Smalltalk	Language as Educational Tool	Logo
Stack Machines	Befunge (SECD Machine, Forth)	Formal Dynamic Semantics	SECD
Data Parallelism	APL	Enumerated Types	Pascal
Coercion	PL/I (Fortran-V)	Backtracking and Theorem Proving	Conniver (Prolog)
Hierarchical Records	COBOL	Argument Handling	Common Lisp, Ada, Python (VB, C#, Suneido, PL/pgSQ)
Pointers & Lists	IPL-V	Coding in Natural Language	Perligata (COBOL, Hypercard)
Parsing	Yacc (LR1, Recursive Descent)	Computational Drama	Shakespeare
Linked Records	AED	Reasoning	Prolog
Mathematical Syntax	MADCAP, MIRFAC, Kleerer-May System	Type Declarators	C
Line Numbers	Basic (Focal, APL)	Data Abstraction	CLU, Alphard
Visual Languages	Piet	Dynamic vs. Lexical Scoping	Scheme
Pattern Matching & Replacement	COMIT, SNOBOL	Knowledge Representation	KRL (Conniver, Microplanner)
Branding	Ada (COMIT, SNOBOL, TRAC)	Stream Processing	Lucid
Dynamic Languages	AMBIT/L	Generic Functions	Common Lisp
Program as Data	Lisp	Reflection	3-Lisp
Macro Processor	TRAC, ML/I, Limp, M4	Metacircular Interpreters	Lisp
Call By Name vs. Call By Value	C, Algol-60	Functional Programming	KRC
Dangling Else	Algol-60	Control Parallelism	Occam
Formal Static Semantics	Algol-68	Domain Specific Languages	HQ9+, MUMBLE
Algebraic Formula Manipulation	Formac (Macsyma, Mathematica)	Build Languages	Make, Ant, Rake (JCL)
Message Passing	Smalltalk (C++, C#, Java, Flavors, Common Loops, CLOS, Scheme, Dylan, Simula, Self)	Scripting	Perl
Objects	Simula (Smalltalk, C++, Java)

The 1972 paper by Alan Kay, in commemoration of the 40th anniversary of the Dynabook. (via Coding Horror.)

This note speculates about the emergence of personal, portable
information manipulators and their effects when used by both
children and adults. Although it should be read as science
fiction, current trends in miniaturization and price reduction
almost guarantee that many of the notions discussed will actually
happen in the near future.