Let me just add some words on this and allow me to link it to today's
IBM systems.
In a certain sense, this machine and its programming system was far ahead
of its time, also compared to today's systems like z/OS and LE. Let me
explain this:
every compile was started through the same command #UEBERSETZE.
The user hadn't to deal with strange compiler program names and workfiles
to be assigned, specific to every compiler.
The interface from the programming system to the compilers was well defined
and was the same for all compilers. The compilers name was derived from the
programming language this way: the first five characters of the programming
language go into the compiler's main module name, for example:
PS&PASCACOMP.
(PS stands for programming system). So it was very easy to add additional
programming language. I once tried to construct an experimental Oppolzer
language,
and of course, the compiler was started using
#UEB,Q=PROG1,SPR=OPAL
In much the same way, each compiler could write debugging information in
a structured
way, defined by the programming system (for breakpoints, called
"Kontrollereignis" in
TR440 speak). So every compiler which supported this - and almost every
compiler did this -
could in case of an error start a programm called - for example -
PS&PASCADUMP,
which generated a language specific dump, where all the variables were
printed in
the language specific format - something that LE did in the 1990s, IIRC.
We never needed
hexadecimal dumps on the TR 440. For FORTRAN and ALGOL, there was even a
tool
which we would today call an online debugger - you could execute your
program step by
step, controlled from the display terminal, and inspect the variables.
Those were the compilers
delivered by Telefunken, the others, like the PASCAL compilers, were
University projects.
The PASCAL compiler was a port of the Zurich P4 compiler by Niklaus
Wirth. The PL/1 compiler,
offered in 1974 by Telefunken, was a port from the Multics project; the
Multics people
sold it to Telefunken and helped on the port.
I think the main difference to today's systems is: the interface between
compilers, run time system,
error handling, debugging tools, descriptive files for the debugger etc.
- this all was part of the
programming system, which was considered as a part of or as an extension
of the operating system.
The operating system was designed with compilers and higher level
languages in mind (in fact,
E.J. Dijkstra once said, that the TR4, which was the father of the
TR440, was a "ALGOL representation
in hardware"). IMHO, only LE tried - very late - a similar approach: LE
tries to play the same role
as an extension to the operating system, but the operating system (z/OS
etc.) is ASSEMBLER-targetted
and has no real interest in the programming system.
I think even today there could be something to learn from this old
system, at least
in the area of usability and support of the developers.
Another topic:
you could mount a volume having a certain volume label in any of your
devices, and
you only had to tell the machine that you want this volume to be read,
and the machine
scanned all devices and located the volume automatically. There was no
need to
specify the number of the device. This was the way it worked from the
beginning in the
late sixties.
This was very helpful, because there were large farms of disk devices
(in the beginning
each removable disk device had a capacity of 20 or 30 MB only - in the
mid 70s there
were larger devices having 250 MB etc.).
Kind regards
Bernd
Am 23.11.2012 17:46, schrieb Bernd Oppolzer:
Now, of course, this reminds me of TAS (Telefunken ASSEMBLER), the
Assembly
Language of the German mainframe Telefunken TR440. It had German
mnemonics,
for example:
S ZIEL,
S stands for "Springe", this is a branch instruction
SGG0 ZIEL,
Spinge, wenn größer oder gleich Null (branch, if the content
of the accumulator is greater than or equal to zero)
B WORT,
Bringe (= load) WORT into the accumulator
BA WORT,
Bringe Adresse = load address of WORT into the accumulator
C WORT,
speiChere WORT (= store), S was already used for "Springe",
so the C was used.
etc. etc. - I hope I got everything right, this was in the late
seventies :-)
The registers and the storage words had 48 bits and two tag bits to
store the type of the content (0 = floating point, 1 = fixed point, 2
= instructions,
3 = text). BTW: this was a time sharing machine with display
terminals; you could
do compiles and tests from every display station. It had a very
sophisticated command
language, and the command language was the same for online and batch.
It was in
use in Germany from 1969 ca. until the mid 80s. Languages were ALGOL,
FORTRAN,
COBOL, PL/1 (a port from the Multics project), PASCAL, BCPL, and others.
Example of the command language:
#UEBERSETZE,SPRACHE=PASCAL,QUELLE=PROG1
could be abbreviated:
#UE,SPR=PASCAL,Q=PROG1
or, if you know the position of the parameters:
#UE,PROG1,PASCAL
(UEBERSETZE = compile)
Recently there was some rumour on the internet that this machine had
the first
mouse (the "Telefunken Rollkugel") together with its graphical display
SIG 100;
there was a description of the Telefunken "mouse" in a Telefunken
brochure,
some weeks before Doug Engelbart presented his "mouse" to the public.
I worked with this "mouse" in 1979 on the TR 440 at Stuttgart university.
Kind regards
Bernd
----------------------------------------------------------------------
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to [email protected] with the message: INFO IBM-MAIN
