Robert Uzgalis:Language Research
Programming Languages
For my whole career I have been interested in human-computer
interfaces. The essence of programming language design is the
creation of an easy interface to control a computer. Complex
tradeoffs between the efficiency of the resulting program and
ease of use of the language has fascinated language researchers
from the early 1950s to today. My involvement with languages has
been extensive. Associated with the following list are short
summaries of my involvement with each language.
In 1962, I wrote a Fortran compiler for an
LGP-30. An early computer with a rotating magnetic drum for a
main memory (4,096 31-bit words), an instruction set with only 16
instructions and limited I/O capabilities. In the summer of 1964,
I used this compiler to create statistical analysis programs for
research on people's buying patterns in the rural towns of the
California central valley.
In 1964-5 at the University of Southern
California, USC, I modified the IBM 1401 Fortran compiler to do
automatic overlay linking of programs to run larger programs on
the machine. I wrote and operated tele-processing programs to do
remote job submittal to the IBM Western Data Processing Institute
at UCLA. The BMD Statistical programs were commonly used for
social science and business research and I modified many of these
programs to generalize them to handle other types of data.
By the mid-1960s I was involved in the Share
(IBM User's Group) specification of a new programming language
that eventually became PL/I. In 1968, the first PL/I-F compiler
arrived at UCLA where I was now working in the Anatomy deparment
as a programmer. I modified it so that it would optionally
implant performance measurement tools in a user's program. These
changes were eventually adopted by IBM and included as a standard
part of their compiler.
In 1968, I developed a graphics facility that
added graphics data types and operators to PL/I. This facility
provided access and control of the IBM 2250 Graphics Display.
This programming system was used for over 10 years to do many
projects in the Health Sciences Computing Facility of UCLA.
In 1969 I used PL/OT to produce animated movies
of the average electro-potential on the surface of the scalp as a
response to visual and auditory stimuli. Ten years later this
technique was used as a diagnostic facility to look for
abnormalities associated with epilipesy.
In 1972, several students working with me
revised and extended the original PL/OT language which was based
on the IBM 2250 display station to work on general graphics
devices. This language became known as PLOT72.
In 1974 I used PL/OT at UCLA to create animated
displays of simulate coastal-wave action in a project for the US
Office of Naval Research. This showed shape, frequency, and power
of ocean waves as they approach a shore line. The topology of the
ocean bottom and intitial direction and wave properties of the
incoming waves were the input to the to the simulation.
In 1979, I worked with another master's
student, Jordan Robison, to again revise PL/OT to add
capibilities and bring it up to date with current technology.
This language was called PLOT79.
In 1979 I spent a sabbitcal leave at Bell
Telephone Laboratories in Murry Hill New Jersey, with the Unix
development group. I worked with Steve Bourne on designing a Unix
workstation. I was primarily responsible for the textual and
graphics display interface and hardware connection to the
display.
In 1969 I began working on an Algol 68
compiler and also with the Algol 68 group to revise the language.
In 1972 I joined the editors of the Algol 68 report for a week of
preparatory editing of the document in Berlin; and in the summer
of 1973 I worked for a month editing the Algol 68 Revised Report
at the University of Alberta, in Edmonton, Alberta. In September
of 1973, I hosted the IFIP
Working Group 2.1 meeting in Los Angeles where the Revised
Report was accepted for publication. In 1975 and for the
following 5 years I was the chairman of the subcommittee of WG2.1
on Algol 68 support. Under my leadership the subcommittee
developed standards for hardware representation, and resolved
many ambiguities in the semantics of the report. In 1980 the
subcommittee was disbanded with its work essentially acomplished.
In 1972 at UCLA with an undergraduate student, Craig
Cleaveland, I wrote a book to introduce one to the formalism used
in the Algol 68 report. This was published by North Holland in
1973 with the Title Grammars for Programming Languages.
The UCLA Algol 68 compiler, was written in a combination of
Algol 68 and 360/Assembler Language. CALGOL took five years of
mainly graduate student labor to complete.
At UCLA, the first year of computer science involved learning
and progrmming in two high-level languages, followed by a quarter
of assembly language programming. From 1978 to 1981 Calgol was
used at UCLA as the second programming language taught. (The
first programming language was either Fortran or PL/I.) After
1981 Pascal was used throughout the first year. During this
period about 300 students a year went through the first year of
compter science.
In 1977, at the System Development
Corporation, as part of a contract for the US Goverment's
Advanced Research Projects Agency, Paul Eggert and I designed a
new programming language called Lingo. Lingo provided type
overloaded `nodes' with input ports and output ports that carried
typed data. The Lingo linker would resolve overloaded node names
and create a valid network for execution.
Programming could be done either graphically
or with ASCII characters. Lingo links between nodes could exist
between multiple machines or within a single machine. Nodes
operated as independent processes, providing parallelism.
Specifications associated with nodes provides
a method to calculate worst case throughput performance for the
entire dataflow network in terms of the parameters of node's
polymorphic types.
In 1978 I ran ARPA Team 405-02 to evaluate
preliminary designs for a common programming language for the US
Deparment of Defense. It is the selection of the Green language
from this exercise from which ADA eventually grew.
As a didactic exercise I am currently
designing an algorithmic language for the 1990s. The computing
world has changed markedly since the development of the major
high level languages in the seventies, many things that needed to
be optimized then can be ignored today, just because of the
increase in speed and memory of modern computers.
For example storing and retrieving data using
any data-type as a key is simple and cheap. As a consequenence
one major reason for data-structures has been eliminated. This
has a major effect on languages, for example, it appears that a
modern language does not need to support a pointer data type at
all, and dynamic storage can be entirely hidden in flexible bags
that group data using an arbitrary index. Proper tools for
maniputating pictures, graphics, and windows are where the real
difficulties in a modern language occur.
© Copyright 1996 Robert Uzgalis. All Rights Reserved.