Early Single Language Systems
1963: Kemeny’s & Kurtz’s Dartmouth system on GE 235
Really only a very rapid remote job entry system.
Source was centrally kept and updates were applied via an interactive terminal editor.
The editor would modify the ‘deck’ which included the Basic program and its input data.
The results of compiling and running the program were very quickly returned to the terminal after an editing session.
The only multiprogramming was integral to the editor program which ran on the Datanet 30.
It gathered key-strokes from many terminals and consider each line upon line end.
Compiling and execution ran on the 235 and was serial.
You could not interact with your running program.
You could not modify a running program.
Only Basic programs could be run and I think they timed themselves.
The only hardware necessary for this system architecture was attachment of terminals, and perhaps a place to store Basic programs and program output online.
CPU architecture of the early 50's would otherwise have sufficed.
In particular no protection was required.
I would not call it timesharing but it provided far more utility to its intended audience than the contemporaneous remote job entry systems whose architecture it more nearly matched.
It was for many practical purposes as good as timesharing, and vastly simpler.
It was unprecedented in its benefit to complexity ratio.
A prime example of Perlis’ dictum: Geniuses remove complexity.
1964: JOSS was nearly contemporaneous with the Dartmouth system.
It too had its own language, called “JOSS”.
I don’t think that it required any more hardware support than the Dartmouth system—indeed its first incarnation on the Johnniac even lacked online storage and the operator would be invoked to fetch yesterday’s program kept on punched cards from a filing cabinet in the machine room.
With JOSS you could modify a running program or its data.
There was no general multiprogramming for the Johnniac and JOSS merged compilation with execution.
JOSS was reincarnated on several subsequent timesharing systems where general multiprogramming was already available.
Uncapher speaks of JOSS.
1967: APL became available on the IBM 360 relying on the general multiprogramming facility available there.
This facility in turn relied on privileged mode, memory protection (storage keys) and timing facilities.
These facilities were mainly to support concurrent batch processing.
The APL language had been invented in 1957 by Kenn Iverson perhaps without the intention of turning it into a programming language.
Arrays are a first class type in APL and operators dealt with arrays as Fortran deals only with array elements.
A rich collection of array operators were efficiently built in.
Time Fault -- back to 1963
CTSS first became operable about 1963.
It ran on a special one of a kind (later two) expensive 7094 machine built by IBM especially for MIT.
It was probably the first multiuser interactive system on which you could run arbitrary machine code.
(Except for XEC * which hung the system.)
It was thus multilanguage.
There was in particular an abbreviated Fortran called Madtran from the University of Michigan.
Madtran was a small fast compiler especially suited for timesharing.
Other compilers became available and the compiler developers could use timesharing to debug their compilers.
CTSS relied on the following hardware architectural extensions:
- Privileged mode
- Memory protection in the form of base and limit.
- Random access disk (generally available but uncommon among 7094s)
- Timing facilities to time and interrupt programs after a time.
- Additional 32K word bank of core memory.
- A specially modified IBM 7750 terminal adaptor.
The terminals were model 28 teletypes.
Editing your file was not a special system operation; the editor was just a normal user mode program.
You could interact with your program, patch it or its data as it ran but the compilers I used there could not incrementally compile.
The Unix architecture stems largely from CTSS.
OS/MVT TSO