From [HoEsWh1969].
CRMS APL allowed the APL programming language to be used to program multiterminal, interactive simulation experiments for social science research. The system was conceived by Professor Austin Hoggatt at the Management Science Laboratory of the Center for Research in Management Science at the University of California, Berkeley. It was designed and built by a team led by Charles Grant and Mark Greenberg beginning in early 1972. By January 1974 it could support one experimenter developing and running an experiment connected to multiple terminals. Work in progress at that time, slated to be complete by summer of 1974, included integration and polishing of an easy-to-use interactive APL subsystem, and design and implementation of a multi-user time-shared operating system. While the project was a technical success, making it easy to write experiments, debug them, run them, and analyze and analyze the results, Hoggatt failed to assemble a community of experimenters to use the facility.
I was a member of the project during 1972, and have attempted to reconstruct the project history. Appendix 1 is an archive of scanned copies of the surviving project documents and source code listings. I plan to offer the original items to the Computer History Museum.
UC Berkeley professors Frederick E. Balderston[MyMi2007] and Austin Curwood Hoggatt[Fr2009] were pioneers in the application of computer-based simulation in economics. Hoggatt's thesis[Ho1957] was said to be "the first thesis in the United States that used simulations with a human-to-computer interface". In 1962 the two published a monumental monograph[BaHo1962] on a simulation of the lumber industry, which included 35 pages of FORTRAN II source code.
In 1964 Balderston and Hoggatt began planning the Management Science Laboratory. In a 1969 paper[HoEsWh1969] demonstrating its use, Hoggatt described it as follows:
"The faculty group at the Center for Research in Management Science has been working with the aid of Architects, Electronics Engineers, Programmers, and Graduate Research Assistants to construct a capital intensive laboratory facility for controlled experimentation in human behaviour. The central instrument in this laboratory is a specially modified, small, time-shared computer which controls interaction among subjects, experimenters, and computer programmes to create complex environments in which the behaviour of subjects may be recorded in computer accessible form. The data may then be transferred directly to large computers for analysis."
The design was guided by a prototype Hoggatt developed during an appointment as Research Professor in the Miller Institute for Basic Research in Science, 1960 to 1961. The lab occupied about 2800 square feet, and much of the space could be reconfigured with wall sections suspended from overhead tracks; it was usually set up with a cubicle for each experimental subject. There were connections for terminals (originally Model 33 Teletypes) and video cameras and monitors.
[HoEsWh1969] described the computer system:
"At the center is a time-shared PDP-5 with DECTAPES, IBM compatible tape, full-duplex teletype multiplexor, analog-digital digital-analog conversion, micro clock, voltage out (one shot) and sense channels and a memory-to-memory link to a PDP-8 computer. The PDP-5 is quiescent responding to a 100 millisecond interrupt to update its clock or to ademand for service from one of the devices which it serves. On demand the PDP-5 slavishly responds or transmits to a peripheral device or stores data. The PDP-8, which has extended arithmetic, operates on a variable quantum break of 10 milliseconds up to 100 milliseconds and can be tuned to match the environmental characteristics of any given experiment. Control over the experiment resides in the PDP-8 which can issue commands to the PDP-5 to send character strings or operate external devices. For example, in creating a log of the experiment the PDP-8 may select characters from the input string of a teletype, add control characters and the real clock time to the string and have the PDP-5 write this information on the DECTAPE."
The PDP-5/8 system was small and slow. By 1970, there was a consensus to replace it with a more powerful computer system. Hoggatt had become an advocate of the APL programming language, which IBM had released for the System/360 in 1968.[FaIv1968] APL offered a concise, powerful notation which Hoggatt believed would be appropriate as a publication language for the models underlying the experiments and could be extended to handle files, multiple terminals and other devices within a single experiment program. Jeffrey Moore, then a graduate student at CRMS, gave an extensive set of requirements under the heading "A Time-Sharing System for Behavioral Science Experimentation" in [ZaStMo1971]. That paper described an investigation into implementing APL on a microprogrammable computer carried out by Rodnay Zaks which did not produce a complete system.[ZaStMo1971, Za1972]
By winter of 1971–1972 a larger project began to assemble a new computer system. [Sv2015] observed:
"[Hoggatt] upgraded the time-sharing microcomputer, terminals, video displays and increased storage capacity with the aid of another NSF grant (SOC75-08177) for the period 1971-1975."
The project was administered by Balderston, who was Chairman of CRMS, and by the Laboratory Advisory Committee, which was chaired by Hoggatt. Two young graduates from Berkeley's Electrical Engineering and Computer Science department were hired to lead the project, Charles A. Grant and Mark L. Greenberg. Grant had received his Ph.D. in 1971;[Gra1971] Greenberg received his in 1972.[Gre1972a] They hired George Morrow[Ma2003] to work on hardware. Morrow had dropped out of high school, but returned to school in his late 20s, earning bachelor's and master's degrees, and entering the PhD program in mathematics at Berkeley. Next they hired David Redell and me (Paul McJones), who had been working together on the recently-terminated CAL Timesharing System at Berkeley's Computer Center.[McRe2023]. Redell was in the Computer Science Ph.D. program; McJones had just completed his B.S. in Engineering Mathematics.
Zaks' investigation used a Digital Scientific META4 Series 16 processor.[DSC70a, DSC71] This processor was originally designed to emulate an IBM 1130, but the read-only control store could be replaced.[DSC1970b] META4s were also being used on campus in Professor Herbert Baskin's PRIME project,[BaBoRo1972] which Grant and Greenberg were familiar with (Baskin was Greenberg's PhD advisor).
Given the limited size of the control store, it was decided to use two META4s sharing a single main memory. The plan was one processor to be dedicated to APL while the other processor executed a general-purpose instruction set as well as controllers for I/O devices. The general-purpose proceessor would run a timesharing system for program development, supervising the APL processor, etc. (Grant and Greenberg had sketched how a suitable microprocessor could be used to implement a CPU and I/O devices in a 1971 paper.[GraGre1971]) Perhaps to reassure Balderston and Hoggatt, the second machine and its system programming language were named SIMPLE. In addition to the two processors and shared memory, interfaces for serial lines [Mo1972], disks [Gre1972b], and tape drives were built.
Grant and Greenberg had hoped to use the APL microcode from Zaks' investigation. My initial assignment was to get it running, but I had problems understanding the code from its source and limited documents. I proposed to Grant and Greenberg to do a new design based on static rather than dynamic name localization, which would allow parsing at compile time rather than runtime. There would be a virtual machine with a set of instructions for a subset of a dialect of APL. There were a few others changes from standard APL:
Grant and Greenberg approved this plan, and I started to design.There was a preliminary machine specification by July [Mc1972b]; the microcode was complete and documented by February 1973.[Mc1973a, Mc1973b, Mc1973c] For the floating-point arithmetic, Dave Redell introduced me to Professor William Kahan, already an authority on computer arithmetic. Given that the projected users would not be numerical analysts, his recommendation was to implement decimal floating-point. I was concerned that this would occupy too much control store, so instead implemented 32-bit binary floating-point. I incorporated correct rounding using a “sticky bit” based on Kahan's lectures.[Mc1972a]
Since the SIMPLE machine wasn't running yet, cross-development was done on an SDS 940 running the Berkeley Timesharing System. There was an assembler for the META4 microcode, and also a simulator with debugging features (e.g., single-stepping and examining registers). I wonder if these tools had been developed for the PRIME project mentioned earlier. We may have started out using the original Project Genie[WiCo2023] SDS 940 in Cory Hall, but we soon switched to the the machine belonging to Resource One, which was part of Project One, an intentional community in San Francisco.[WiCo2024]
I left the project after delivering the APL processor, but I learned that when my microcode was installed in the hardware read-only memory (which involved manually peeling little foil squares off printed circuit boards), it worked the first time. See Appendix 3 for four changes that were made later.
In source code such as [Xx1974a] and [Xx1974b], the two machines were often referred to as the AIPU and SIPU (IPU = Instruction Processing Unit). I believe Grant designed and implemented the SIPU.
In early discussions, it was decided to build a message-based system, with support in the microcode for basic process scheduling and message sending. Rather than switching between user and supervisor mode, there would be a kernel process with extra privileges that would handle system activities that could not be handled in microcode. I/O devices would appear to software as regular processes, so there would not be an interrupt mechanism. An early working document by Redell described messages as being sent to a (process, port) pair and described fairly complicated mechanisms to be implemented in microcode.[Re1972a] A later working document described a much simpler mechanism for the microcode, but noted that it was sufficient to enable a trusted "kernel" process to implement flexible message channels.[ReMc1972]
APL processes communicated by sending messages to mailboxes, and multiple processes could queue up to wait for messages on a single mailbox.[GeeEtAl1974]). APL processes had no microcode support; multiplexing of the APL processor was performed by APL Runtime Services.
*** To be supplied. Cite [McJones1972d] for APL syntax.
[GeeEtAl974] explain how an experiment program is organized, and includes application programming interfaces. An experiment consists of a set of cooperating processes — isolated instances of running programs. Each process is started by executing a function from the experiment program, but they share no global or local variables. Each subject process has an attached terminal. A pair of mailboxes connects the experimenter's process with each subject processe. A mailbox allows one-way transmission of a sequence of APL objects (scalars, vectors, or matrices) between two endpoints. The endpoints can be processes, files, and timers. An experiment may include one or more robot processes. A robot process substitutes for a terminal, and thus interacts with the corresponding subject process. The code to implement these facilities includes the APL Runtime Supervisor [Xx1974b], which is written in SIMPLE, and also a set of library functions (as described in [GeeEtAl974]) written in APL.
Sheldon Linker wrote runtime library routines to achieve "full APL" based on the subset directly executed by the APL processor. He also assisted in writing experiment programs and helped run experiments.[Li2024]
"CRMS APL/SIMPLE Integrated Language Processing System: Design Considerations"[Re1972b] was an early sketch of what we would now call an Integrated Development Environment (IDE): it would combine editing, compiling, and debugging within a single command-line interface, and wherever possible would unify the commands for APL and SIMPLE. The compiler would be invoked automatically whenever program execution was requested and the program text had been edited.
"Language System: Interim Command Language"[Re1972c] fleshed out the command-line interface alluded to in the previous document. It gave a syntax for line-oriented addresses for the editor and debugger, and then described the commands for editing and program management.
"Preliminary Language System User Manual"[Re1973a] repeated the syntax for line-oriented addresses with some additions, defined two "program topology modes" for context searches (per function vs. whole program, and linear vs. circular or "end around"), and then defined an additional terse "operator/operand" syntax for a number of the most frequently-used editing commands.
The following two tables were constructed by searching the source code for the SIMPLE Interactive Language System[Xx1974a] and the APL Runtime Supervisor.[Xx1974b]).
| SP | SELECT PROGRAM |
| SR | SELECT RUNTIME |
| SB | SET BREAKPOINT |
| CB | CLEAR BREAKPOINT |
| DO | DO FUNCTION [start debuggee process] |
| GO | GO COMMAND [start debuggee process] |
| PC | PRINT CODE [and line-table entry] |
| ST | DUMP SYMBOL-TABLE ENTRY |
| EX | EXIT FROM LANGUAGE SYSTEM |
| PV | PRINT VARIABLE |
| DB | DEBUG SPECIFIED PROCESS |
| SZ | SET SIZES [array block storage, stack] |
| NP | NEW PROGRAM |
| SP | SELECT PROGRAM |
| CP | COMPILE PROGRAM |
| DP | DELETE PROGRAM |
| ET | ENTER TEXT |
| MT | MODIFY SINGLE LINE IN TEXT BUFFER |
| TT | TYPE CONTENTS OF TEXT BUFFER |
| AF | APPEND FUNCTION FROM TEXT BUFFER |
| AT | APPEND TEXT |
| IT | INSERT TEXT |
| DT | DELETE TEXT |
| RT | REPLACE TEXT |
| LT | LOAD TEXT |
| MV | MOVE POINTER |
| RF | READ FUNCTIONS |
| ST | DUMP SYMBOL-TABLE ENTRY |
| SR | SELECT RUNTIME LIBRARY |
| RS | RECOVER STATE |
| PC | PRINT CODE [and line-table entry] |
| SB | SET BREAKPOINT |
| CB | CLEAR BREAKPOINT |
| PD | PRINT DATA |
| SD | STORE DATA |
| DS | DISPLAY STACK |
| DO | DO FUNCTION [start debuggee process] |
| GO | GO COMMAND [start debuggee process] |
| PV | PRINT VARIABLE |
| IN | IN [set function activation context] |
| WH | WHERE [print current location?] |
| PS | PRINT SEGMENT |
| EX | EXIT FROM LANGUAGE SYSTEM |
In January 1974, [GraGreRed1974] reported:
"The current system includes 64k 32-bit words of core memory, two 12-million-word disk units, one tape drive, and provisions for the connection of up to 64 terminals. The APL processor is connected by "start" and "stop" signals to the central processor and has access to the core memory.
and:
"As of January 1973, the hardware for the system was operation. Now, January 1974, the APL subsystem is operational and has been used to develop a prototype experiment. The simulated APL primitive functions, including mathematical routines, are mostly completed. The current version of the operating system supports only one experiment at a time. Preliminary versions of the editing and debugging facilities are available. Work in progress includes integration and polishing of an easy-to-use interactive APL subsystem, and design and implementation of a multi-user time-shared operating system. Completion of the development is scheduled for summer of 1974."
A 1976 report described the system as:[Sv2015, footnote 101]
“[a] time-sharing system based on two microprogrammable META4 computers, with a shared core memory of 120,000 32-bit words, two disks having storage capacity totaling 24 million words, a magnetic-tape unit for backup and data preparation, a link to the Berkeley Campus CDC 6400 computer; modems for linking users and other systems outside the laboratory; eighteen hard-copy terminals, and a CRT display system consisting of twelve CRT screens with keyboard and light-pen and RAMTEK support unit.”
Reports of experience with this system are few. In a 1977 paper "On the Uses of Computers for Experimental Control and Data Acquisition", Hoggatt provides anecdotes but does not cite published results. For example:
In his PhD thesis and a subsequent paper on the history of experimental economics, Andrej Svorenčík illusttrates how Hoggatt's work on his laboratory provided the example and technical impetus for experimental economics to adopt this approach, but he was unable to create the community around the laboratory that proved necesary as this approach spread through Europe and America in the late 1980s and early 1990s.
"The laboratory failed because it hardly produced any research, even though it
swallowed the same amount of resources as Smith’s Economic Science Laboratory and
Plott’s Experimental Economics and Political Science Laboratory two decades later — more than a million 1985 US dollars or over two million dollars in current terms. ... In contrast, its success lay in the desire of others to emulate 'Auggie.' Hoggatt showed to others that computerization goes hand in hand with better experimental control, new types of intervention, and speeding up the execution of experiments and the collection, storage and processing of data. This was decades before the benefits of computerization would have become apparent without Hoggatt’s laboratory."[Sv2015]Hoggatt’s success lays in the desire of others to emulate “Auggie.” He showed to others
that computerization goes hand in hand with better experimental control, new types of
intervention, and speeding up the execution of experiments and the collection, storage
and processing of data. Far more successful were Selten and Smith in the 1980s. Their
experience with Hoggatt’s laboratory was important in their decision to pursue their
own laboratories and they focused equally on creating a community around their
laboratories.[Sv2018]
Hoggatt lamented:[ArEtAl1992]
"After spending large sums of NSF money to capitalize this facility, the University of California, Berkeley scrapped it for want of funds to pay for maintenance."
I don't know how long the system continued to operate. George Morrow, who did the hardware for the project, went on to found Thinker Toys and Morrow Designs, and was one of the people who standardized the S-100 bus used in many early microcomputers. Grant and Greenberg went on to found North Star Computers. Rodnay Zaks went on to found Sybex, a publisher of books on computer programming. Jeffrey Moore, an advisor for Zaks' investigation, received his PhD in business and spent the rest of his career at Stanford. Dave Redell completed his PhD in computer science and then accepted a position as an assistant professor at MIT. After several years he returned to the Bay Area, working successively at Xerox, DEC Systems Research Center, AgileTV, and Google. I worked at a small software house named Virtual Memory Systems, then IBM Research, Xerox, Tandem, DEC Systems Research Center, E.piphany, AgileTV, and Adobe. Paul Gee went to Lawrence Berkeley National Laboratory, then joined Grant and Greenberg at North Star, then worked at TRW Financial Systems, and finally another long stint at Lawrence Berkeley National Laboratory.
The original CRMS APL system was done as part of a Systems Development effort under National Science Foundation Grant GS-32138. Additional work was done under Grant SOC75 -08177.
Dave Redell shared recollections and supplied copies of a number of documents and the two SIMPLE source code listings. Sheldon Link supplied recollections.
Over the life of the system, four changes (which are noted in pencil on the listing) were made to the APL microcode, which I'd debugged on the simulator before leaving the project in January 1973: