Conference turris::languages

re .0
    

>   * Evil reputation.  Preference will be given to languages only spoken
>     of in horrified whispers.
    
    There was a language called EVIL, wasn't there, or is my memory failing
    me? I seem to recall that it was aptly named.

>Two kinds of language I am *not* generally interested in are assemblers
>and MFTLs used by a community of one.
    
    MFTL = ?

    	How about re-implementing the original version of Basic?
    
    	Variable names must be a letter, optionally followed by a single 
    digit, and with "$" or "%" tacked on the end to indicate a string or
    integer variable. There should be no support for interactive usage, 
    since it only supported punched card input and line printer output. 
    Every line must have a numeric label, and you can only have a single 
    statement per line....
    
    	Sorry I don't have softcopy of the specifications, but someone
    somewhere might have.
    
    
    	A real challenge would be a full implementation of Algol-68. I once
    saw a paper that claimed that because it didn't insist on
    definitions before use, permitted redefinition and overloading of 
    operators, ... it was in theory not possible to produce a compiler of
    less than 6 passes. (oh, in that addition statement 30 lines ago, one
    of the variables was of type "fred" - eventually I might get around to
    telling you what "fred" type variables are, and how to add them).

    	You mentioned Focal in .0.  If it is my VAX implementation then I 
    looked at getting that running on AXP. A fair bit of it is fairly
    portable Bliss, and most of the Macro-32 would go through the cross
    compiler. The problem was the expression evaluator - only about 500
    bytes of Macro-32 code on VAX, but a nightmare to port.

Notice that .0 was reposted from the Usenet newsgroup comp.compilers, and that
the author is Eric Raymond, [email protected] .  If you actually want to make a
suggestion, you will need to mail it to him.

	-Neil

re: .2
>                              -< Dartmouth Basic >-
>
>    	How about re-implementing the original version of Basic?
>    
>    	Variable names must be a letter, optionally followed by a single 
>    digit, and with "$" or "%" tacked on the end to indicate a string or
>    integer variable. There should be no support for interactive usage, 
>    since it only supported punched card input and line printer output. 
>    Every line must have a numeric label, and you can only have a single 
>    statement per line....
    
Hmmm, as I remember Dartmouth BASIC (all uppercase), there wasn't any integer
variables, only floating-point and string.  And it was designed specifically
for interactive usage...to add a line to the program you just typed it in.
The line number indicated where in the program the new line was to go.

Of course that was a long time ago and my memory might be fuzzy.

-Hal

    re .5
    
    It is also my recollection that % was a later addition (for denoting
    integer variables).

As long as I'm ratholing, I might as well go all the way. :-)

I have a soft spot in my heart for Dartmouth BASIC because it was my very
first exposure to computer programming back in the late 1970's.  I was in
a strange point in my life where I had quit college after getting around
3/4 of a degree in Music Theory.  After being poor for awhile, I decided to
go back to school and get a degree in something I could make some money with.
My first attempt was to pursue a business major.  At my school, one of the
required business courses was a computer programming course.  When I took
the obligatory course I was very surprised to find that here was a subject
that I really loved and that I seemed to be very good at.  I changed my major
from business to computer science and never looked back!

The language used for the course was (essentially) Dartmouth BASIC, and the
textbook was Kemeny and Kurtz (one of whom invented the language, but I can't
remember which right now.  I think it was Kemeny [sp?]).

One thing that I remember noticing is that when I first started in computer
science it seemed that most of the people in the field were there because
they loved the subject and had an aptitude for it.  By the time I finished
my degree there was already starting to be a lot of people in the program
who were there because they thought computer programming was a good way to
make money.  Many of them didn't have a knack for it at all, and really should
have been in a different field.

-Hal

    	You are right. I am getting rusty. The "%" was a later addition. It
    is true that in 1964 Basic had no interactive capabilities. Even when
    it added interactive capabilities it was still a much inferior language
    to Focal, but Dartmouth College was a large and prestigious educational
    institution, while Focal was produced by some virtually unknown Maynard
    manufacturer of digital circuitry modules that had decided to start
    using its own modules to build computers�. In the circumstances it was
    obvious that Basic would win out, even though it was the inferior
    language. Both of them date from around 1963-1964.
    
    �I don't know the actual figures, but I doubt if DEC had shipped more
    than about 300 computers (sorry, Programmable Digital Processors) when
    Focal was first implemented for the PDP-5.

From: [email protected] (Eric Raymond)
Subject: Retrocomputing Museum Progress Report
Keywords: history, comment
Organization: Netaxs Internet BBS and Shell Accounts

This is followup on my "Languages From Hell" offer (which is the contents of
the file CHARTER referred to below):

			THE RETROCOMPUTING MUSEUM
		(manifest and progress report #1, September 20th 1994)

The Retrocomputing Museum is dedicated to programs that induce sensations that
hover somewhere between nostalgia and nausea.  Many are emulations of languages
that were once important, but are now merely antiques.  A few are games and
curiosities that recall bygone ages, nice if you want to be able to demonstrate
to the younger set what life was like back when programmers were real men and
sheep were nervous.

The Museum site is ftp:locke.ccil.org:pub/retro.

The curators of the Museum are:
	Eric S. Raymond <[email protected]>
	John Cowan <[email protected]>

Summary list of packages in the Museum:
	algol-60, cfoogol, focal, intercal, jcl, mixal, oisc, pilot, teco,
	trac, wumpus

Following the package descriptions is a "COMING SOON..." section describing
current Museum projects, and a want list of specifications and implementations
we'd like to add to the Museum.  See also the file CHARTER.

				LANGUAGES

algol-60
	An interpreter for Algol-60, the common ancestor of C, Pascal,
	Algol-68, Modula, and most other conventional languages that
	aren't BASIC, FORTRAN, or COBOL.  Correctly described by Edsger
	Dijkstra (one of its co-designers) as "a great improvement on
	many of its successors".  This distribution includes TeX source
	for the Algol 60 Report.

cfoogol
	A compiler for a very, very tiny subset of Algol (no procedures,
	even).  More a demonstration on how to write a recursive descent
	parser than anything else.  Generates stupid but portable C code.

focal
	A very archaic educational language, ancestral to MUMPS.
	This implementation is due to be replaced shortly by a better one.

intercal
	A computer language designed by Don Woods and James Lyons in 1972.
	INTERCAL is purposely different from all other computer languages
	in all ways but one; it is purely a written language, being totally
	unspeakable.  Said by the authors to stand for "Computer Language
	With No Pronounceable Acronym".

jcl
	The JCL shell.  If you ever wondered what programming an IBM/360
	was like, here's your chance to find out.  No man page, but there
	is an included sample `Hello, World' JCL deck that it will run.

mixal
	An implementation of the MIX pseudoassembler used for algorithm
	description in Donald E. Knuth's "The Art Of Computer Programming",
	vol I.  This preliminary release doesn't do floating point and has
	little documentation as yet, but it works well enough to be used
	in conjunction with the book.

oisc
	You've heard of RISC, Reduced Instruction Set Computers?  Well, here
	is the concept taken to its logical extreme -- an emulator for a
	computer with just one (1) instruction!  Sample programs in the
	OISC machine language are included.

pilot
	The reference implementation for IEEE standard PILOT, a horrible
	language designed in 1962 on IBM mainframes that a group of
	ancient academics was still insane enough to be using in 1990 ---
	and not only using but *standardizing*.  I (esr) wrote this
	implementation as a weekend hack.

teco
	Yes, it's the Editor From Hell...the infamous TECO, bane of lusers
	and tricky, unforgiving tool of master hackers.  Build this to find
	out (a) what we lived with before Emacs, and (b) how expressive line
	noise can be.  I have POSIXified the code.  Note: this is 1986 TECO,
	there's a newer 1993 version that doesn't POSIXify cleanly.

trac
	An extremely funky computer language based entirely on macro
	processing.  There is an interpreter written in Perl, and a
	text file documenting the language and the implementation.  This
	implementation is by John Cowan <[email protected]>.

				GAMES

wumpus
	A faithful clone of the classic Hunt The Wumpus game, exactly as it
	appeared in 1972 on the Dartmouth Time-Sharing System.  Also includes
	an original but strangely similar game, superhack.

			COMING SOON TO THE MUSEUM

dibol (John Cowan)
	Digital's Business Oriented Language, born on the PDP-8 and later
	moved to the PDP-11.  Compiler in Perl, but generates Standard C.
	Comes with a Posix-compliant library that does almost all of the
	real work.  DIBOL is like COBOL, dumbed down as far as possible....

algol-60c (John Cowan)
	The real Algol-60 compiler.  Will generate GNU (non-Standard) C.
	This is the big project, and won't be available for a while yet.

Magnus Olson is working on a BCPL-to-C compiler.

Jonathan Chandross <[email protected]> is building a better FOCAL.

Richard Wendland <[email protected]> is working on an Algol-68-to-C
	compiler, to be available in mid-1995.

			POSSIBLE FUTURE PROJECTS

plankalkul (Eric S. Raymond)
	An implementation of the very first high-level computer language
	ever, Zuse's Plankalkul for the Z-3.  I'll write this if I get
	enough docs on the language to do it, and Matthias Neeracher is
	working on that.

plmtoc (?)
	There is a PLM/386 parser and symbol-table manager available,
	plm-parse, at iecc.com:pub/file/plm.shar.gz.  This ought to
	be turned into a PL/M-to-C compiler.

bliss (?)
	The Museum has an incomplete BLISS-to-C compiler.  We're looking
	for someone to finish it who has BLISS and/or VMS experience.

			THINGS WE ARE ESPECIALLY LOOKING FOR

Implementations, or softcopy specifications, for the following languages:
	Plankalkul, IPL-V, RPG, JOVIAL, CORAL, JOSS, POP-2 or POP-10,
	1401 Autocoder, MAD, PL/M.
Sample programs to add to the distributions for the following languages:
	FOCAL, ALGOL-60, JCL, TECO.


--
					Eric S. Raymond <[email protected]>
[Nitpick: I believe that Focal and MUMPS were unrelated, despite some
syntactic similarity.  Focal was basically as much of JOSS as the author
could squeeze into a 4K PDP-8. -John]
-- 
Send compilers articles to [email protected] or
{ima | spdcc | world}!iecc!compilers. Meta-mail to [email protected].

    re .7: If you buy the latest version of True BASIC (from True BASIC
    Inc., runs even on Alpha OSF/1!) you'll see that the manual still has
    John G. Kemeny and Thomas E. Kurtz in fairly large print on the
    cover...
    
    I think I first used BASIC in the late 60's, and it certainly didn't
    have integers of any of this other high-tech stuff then...
    
    As to languages from hell, how about C++ ?   � :-)
    
    Around '70 I used a big Univac 1100-series mainframe, which had an
    unbelievable number of language implementations (I think there were
    four Algols).
    
    BTW, do we still sell CORAL?

    I doubt that we still sell CORAL� these days, we only just sell Ada :-)
    
    	Rik
    
    �Didn't it run in PDP-11 emulation mode on the VAX ?

    	The CORAL compiler ran in emulation mode on VAX, but I think it
    generated native mode code eventually.
    
    Dave, who wrote the CORAL example for the VMS V1.0 system services
    manual. It crashed the FT compiler when I tried to compile it. 

Re: .2, .5, .6, .7, .8, and .10

I worked on the original Dartmouth BASIC time-sharing system which ran
on an General Electric 265 system.  The first time-shared BASIC
program ran on 1 May 1964.  I still have my BASIC manual and it is dated
1 January 1965.

The original BASIC had only numeric variables (which were implemented
in 40-bit floating point).  The use of $ for string variables came
later.  I do not believe that Dartmouth ever separated the concepts of
numeric and integer variables so Dartmouth BASIC never used % for
integer variables (at least it did not when I graduated in 1969).

As mentioned in .2, the original BASIC could not do run-time terminal
input although it did do terminal output.  This BASIC only had 15
statements (LET, READ, DATA, PRINT, GOTO, IF-THEN, FOR, NEXT, END,
STOP, DEF, GOSUB, RETURN, DIM and REM).  The INPUT statement which
allowed run-time reading from the terminal did not appear until
sometime in 1965.  The MAT statement, which did matrix operations, was
also added to the time-sharing version in 1965.  String variables,
using a $ sign, did not appear until 1966 or 1967.  (I could get the
exact date by digging some of my newer BASIC documentation out of my
attic). 

The original BASIC system only swapped 6K of 20 bit words for each
user.  The swap device's *fastest* seek time was 1/4 second so the
scheduling quantum was at least 5 seconds long.  It is amazing that
such a system could efficiently time-share up to 40 simultaneous users.

My favorite language from the past is MAD which is an acronym for the
Michigan Algorithm Decoder.  It was developed at the University of
Michigan, was based on Algol-58, ran on a 7094, used the FORTRAN
character set, and was compatible with FORTRAN.  On the MIT CTSS
time-sharing system FORTRAN source code was compiled using the the
MADTRN system.  MADTRN translated FORTRAN source to MAD source and
then compiled it with the MAD compiler.  This used significantly less
compile-time than using the IBM FORTRAN compiler (although the MAD
run-time code was much less optimized).

It was a strange language for RT11 (PDP-11). I do not remember how to spell it
correctly: REFAL(? Recursive Function Language). It was relly from hell. 

And do not forget APL.

    FOCAL maybe ? DIBOL ? (Doubt that one)

    Does anyone know where the library has moved to?  It's no longer at the
    ftp site referred to in the base note.
    
    Matt