Lambda the Ultimate

History of LISP (software collection committee) edited by Paul McJones. Abstract:

The goal of this project is to locate source code, design documents, and other materials concerning the original LISP I/1.5 system, and as many of its follow-ons as possible. LISP was one of the earliest high-level programming languages and introduced many ideas such as garbage collection, recursive functions, symbolic expressions, and dynamic type-checking. This is a pilot project of the Computer History Museum's Software Collection Committee to develop expertise in the collection, preservation, and presentation of historic software. Comments, suggestions, and donations of additional materials are greatly appreciated.

I ran across this page by accident while googling for "lisp assembler lap" because I'd recently learned LAP was the standard acronym for lisp assembly program (ie a lisp based assember), which also described what I was currently trying to do. It's funny how often a new idea is just the Nth repetition of many old ideas. :-)

Anyway, this page links a wealth of interesting material on early Lisp implementations. (Unfortunately a number of the PDF documents don't open on my current machine, so I can't read several of the items I find most interesting, including everything L. Peter Deutsch authored.)

I'm curious if anyone has thought about or know of any languages that are aimed towards solving the parallel class hierarchy problem. If you're unfamiliar it's a term GoF uses a lot -- it refers to when you delegate out part of the responsibilities of a class to another class, so you end up with class hierarchies like:

A -> B
  -> C

AWindow -> BWindow
        -> CWindow

ARenderer -> BRenderer
          -> CRenderer

In this trivial example nested classes can help improve the encapsulation but parallel classes still always have a sloppy feeling to me.

More generally, does the public/protected/private scheme make parallel class hiearchies inevitable? Does AOP handle this problem somehow?

A Core Calculus for Scala Type Checking, is a new paper by the Scala team.

Abstract. We present a minimal core calculus that captures interesting constructs of the Scala programming language: nested classes, abstract types, mixin composition, and path dependent types. We show that the problems of type assignment and subtyping in this calculus are decidable.

The paper revolves around the question of decidability of type checking in Scala. The following quote summarizes the background of this question.

Scala’s approach to component modeling is based on three programming language constructs: modular mixin composition, abstract type members, and explicit self-types. All three have been studied in the vObj calculus. A key concept of the vObj calculus, path-dependent types, is also present in Scala. However, some other constructions of vObj do not correspond to Scala language constructs. In particular, vObj has first-class classes which can be passed around as values, but Scala has not.
First-class classes were essential in establishing an encoding of F<: in vObj, which led to a proof of undecidability of vObj by reduction to the same property in F<:. However, since Scala lacks first-class classes, the undecidability result for the calculus does not imply that type checking for the programming language is undecidable.

Ehud: Given current interest in Scala and its more or less unique (don't want to raise controversy here) position as being both a functional and an OO language, furthermore being much more than a toy language, would it be a good idea to give Scala a place in the Spotlight section?

Interesting draft paper on the History of Haskell by Simon Peyton Jones, Phil Wadler, Paul Hudak, and John Hughes.

This paper describes the history of Haskell, including its genesis and principles, technical contributions, implementations and tools, and applications and impact.

This paper is aimed at History of Programming Languages - HOPL III to be held in June 2007.

In 1978, the first History of Programming Language Conference (HOPL) described the development of 13 computer programming languages, the people who participated in that work, and the context in which it was undertaken. In 1993, HOPL-II contained 14 papers on the genesis and evolution of programming languages. It is time for HOPL-III, to be held with FCRC 2007 in San Diego. Each HOPL-III paper should detail the early history or evolution of a specific programming language. Preliminary ideas about each language should have been documented by 1996 and each language should have been in use by 1998.

Which leaves the question of which PLs should take part in HOPL-III?
(I guess I need to go back and remember which were documentend in I & II).