History

A-Z of Programming Languages: Erlang

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

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?

A Brief, Incomplete ... History of Programming Languages

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.

ADD 50 TO COBOL GIVING COBOL

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.

Announcing the Haskot

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

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.

The programming languages behind "the mother of all demos"

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).

HOPL III: The When, Why and Why Not of the BETA Programming Language

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).

Guy Steele & Richard Gabriel: 50 in 50

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 LoopsFortran (Pascal,APL)Guarded CommandsAlgol-68
Array OriginC, Fortan, Pascal, APLExtensible LanguagePPL
Domain Specific LanguageAPTStructured ProgrammingBLISS, INTERCAL
Text vs. EnvironmentAlgol-60, Lisp, SmalltalkLanguage as Educational ToolLogo
Stack MachinesBefunge (SECD Machine, Forth)Formal Dynamic SemanticsSECD
Data ParallelismAPLEnumerated TypesPascal
CoercionPL/I (Fortran-V)Backtracking and Theorem ProvingConniver (Prolog)
Hierarchical RecordsCOBOLArgument HandlingCommon Lisp, Ada, Python (VB, C#, Suneido, PL/pgSQ)
Pointers & ListsIPL-VCoding in Natural LanguagePerligata (COBOL, Hypercard)
ParsingYacc (LR1, Recursive Descent)Computational DramaShakespeare
Linked RecordsAEDReasoningProlog
Mathematical SyntaxMADCAP, MIRFAC, Kleerer-May SystemType DeclaratorsC
Line NumbersBasic (Focal, APL)Data AbstractionCLU, Alphard
Visual LanguagesPietDynamic vs. Lexical ScopingScheme
Pattern Matching & ReplacementCOMIT, SNOBOLKnowledge RepresentationKRL (Conniver, Microplanner)
BrandingAda (COMIT, SNOBOL, TRAC)Stream ProcessingLucid
Dynamic LanguagesAMBIT/LGeneric FunctionsCommon Lisp
Program as DataLispReflection3-Lisp
Macro ProcessorTRAC, ML/I, Limp, M4Metacircular InterpretersLisp
Call By Name vs. Call By ValueC, Algol-60Functional ProgrammingKRC
Dangling ElseAlgol-60Control ParallelismOccam
Formal Static SemanticsAlgol-68Domain Specific LanguagesHQ9+, MUMBLE
Algebraic Formula ManipulationFormac (Macsyma, Mathematica)Build LanguagesMake, Ant, Rake (JCL)
Message PassingSmalltalk (C++, C#, Java, Flavors, Common Loops, CLOS, Scheme, Dylan, Simula, Self)ScriptingPerl
ObjectsSimula (Smalltalk, C++, Java)

A Personal Computer for Children of All Ages

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.

XML feed