History of CRMS APL

Paul McJones
paul@mcjones.org

10 July 2024

Abstract

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.

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.

Introduction

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.

Management Science Laboratory

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.

Floor plan of Management Science Laboratory
FIGURE 1. FLOOR PLAN OF THE MANAGEMENT SCIENCE LABORATORY.
From [HoEsWh1969].

[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."

CRMS PDP-5/PDP-8 circa 1972
CRMS PDP-5/PDP-8 circa 1972. Photo by Paul McJones.

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]

CRMS APL project

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.

Hardware

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.

CRMS PDP-5/PDP-8 circa 1972
CRMS META4 system circa 1973. Photo by Paul McJones.

Microcode

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.

SIMPLE operating system

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.

Compilers

*** To be supplied. Cite [McJones1972d] for APL syntax.

APL Runtime Services

[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]

Language Services

"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]).

APL Language System commands (from [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]

SIMPLE Language System commands (from [Xx1974a])
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

Status snapshots: 1974, 1976

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.”

Impact

Reports of experience with this system are few. In his PhD thesis[Sv2015] on the history of "experimental economics", Andrej Svorenčík concluded:

"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."

Hoggatt himself wryly observed:[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."

Afterword

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.

References

[ArEtAl1992]
Michel Araten, et al. The Winter Simulation Conference: Perspectives of the Founding Fathers. In Proceedings of the 24th conference on Winter simulation (WSC '92). Association for Computing Machinery, pages 37–62. ACM Digital Library
[BaHo1962]
Frederick E. Balderston and Austin Curwood Hoggatt. Simulation of Market Processes. Berkeley: Institute of Business and Economic Research, University of California, 1962. babel.hathitrust.org
[BaBoRol1972]
Herbert B. Baskin, Barry R. Borgerson, and Roger Roberts. PRIME: a modular architecture for terminal-oriented systems. In Proceedings of the May 16-18, 1972, Spring Joint Computer Conference (AFIPS '72 (Spring)). Association for Computing Machinery, New York, NY, USA, pages 431–437. ACM Digital Library
[DSC1970a]
Digital Scientific Corporation. The META4 Series 16 Computer System: Preliminary System Manual. Publication No. 7006MO, June 1970. PDF at bitsavers.org
[DSC1970b]
Digital Scientific Corporation. The META4 Series 16 Computer System Read-Only Memory (ROM) Reference Manual. Publication No. 7024MO, March 1970. PDF at bitsavers.org
[DSC1971]
Digital Scientific Corporation. The META4 Series 16 Computer System: System Manual. Publication No. 7032MO, May 1971. Supersedes Publication No. 7006MO. PDF at bitsavers.org
[FaIv1968]
A. D. Falkoff and K. E. Iverson. APL\360 User's Manual. IBM Corporation, August 1968. bitsavers.org
[Fr2009]
Ute Frey, In Memoriam: Austin Hoggatt 1929 – 2009. senate.universityofcalifornia.edu
[GraGre1971]
Charles A. Grant and Mark L. Greenberg. The Uses of a Microprocessor in an Interactive Computing System. 4th Hawaii International Conference on System Sciences, January 12-14, 1971. 19710100-cag_mlg-uses_of_a_microprocessor
[Gra1971]
Charles A. Grant. Command Communication Between Processes. PhD thesis, University of California, 1971. mathgenealogy.org
[GraGreRe1974]
Charles A. Grant, Mark L. Greenberg, and David D. Redell. A computer system providing microcoded APL.
[Gre1972a]
Mark L. Greenberg. Secondary Storage Management in Time-Sharing Systems. PhD thesis, University of California, 1972. mathgenealogy.org
[Ho1957]
Austin Curwood Hoggatt. Simulation of the Firm. PhD thesis, University of Minnesota, 1957. primo.lib.umn.edu
[HoEsWh1969]
Austin C. Hoggatt, Joseph Esherick and John T. Wheeler. A Laboratory to Facilitate Computer-Controlled Behavioral Experiments. Administrative Science Quarterly, Volume 14, Number 2, June 1969, pages 202–207. JSTOR
[Ho1973a]
Austin Curwood Hoggatt, editor. Proceedings of the 1973 Winter Simulation Conference. Sponsored by ACM/AIEE/SHARE/SCi/TIMS, January 1973. files.eric.ed.gov
[Ho1973b]
Austin Curwood Hogatt, chairman. Night in a Berkeley Laboratory. Announcement of a special evening session in Hoggatt's Management Science Laboratory. In [Ho1973a], page 715.
[HoGrMo1973]
Austin Hoggatt, Mark Greenberg, and Jeffrey Moore. A Micro-Programmed APL Language Laboratory Control System. In [Ho1973a], page 716, and online.
[Li2024]
Sheldon Linker. Personal communication, 3 June 2024.
[Ma2003]
John Markoff. George Morrow, a Personal Computer Visionary, Dies at 69. The New York Times, 9 May 2003, page A29. nytimes.com
[McRe2023]
Paul McJones and David Redell. History of the CAL Timesharing System. IEEE Annals of the History of Computing, Volume 45, Issue 3, July-September 2023, pages 80-91. IEEE Xplore
[MyMi2007]
John G. Myers and Raymond E. Miles. In Memoriam: Frederick E. Balderston 1923 – 2007. senate.universityofcalifornia.edu
[Sa2016]
Kay Savetz. Rodnay Zaks, Founder of Sybex Books — interview. YouTube, audio recording, 14 October 2016. YouTube.com
[Sv2015]
Andrej Svorenčík. The Experimental Turn in Economics: A History of Experimental Economics (January 30, 2015). University of Utrecht: Utrecht School of Economics Dissertation Series #29. ssrn.com
[WiCo2023]
Wikipedia Contributors. Project Genie. Wikipedia, The Free Encyclopedia, last revised 27 March 2023 19:13 UTC. en.wikipedia.org
[WiCo2024]
Wikipedia Contributors. Project One (San Francisco). Wikipedia, The Free Encyclopedia, last revised 21 February 2024 20:57 UTC. en.wikipedia.org
[ZaStMo1971]
Rodnay Zaks, David Steingart, and Jeffrey Moore. A firmware APL time-sharing system. Proceedings of the May 18-20, 1971, Spring Joint Computer Conference (AFIPS '71 (Spring)). Association for Computing Machinery, pages 179–190. ACM Digital Library
[Za1972]
Rodney Zaks. A Microprogrammed APL Implementation. Ph.D. thesis, University of California, Berkeley, June 1972. Published under the same title by Sybex, 1978.

Acknowledgements

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.

Appendix 1: Archived documents and source listings

Hardware

[Mo1972]
George Morrow. Serial Line Input/Output System. Systems Group, Center for Research in Management Science, 24 July 1972. 19720724-gcm-serial_line_io
[Gre1972b]
Mark L. Greenberg. Disk Interface and Controller Reference Manual. Technical Document, Systems Group, Center for Research in Management Science, 12 July 1972. 19720712-mlg-disk_io

Microcode

Documents

[Gra197x]
Charles Grant? SIMPLE Instruction Processing Unit Reference Manual. Cited by [19730726-mlg-simple_lang_ref] but no known copy.
[Mc1972a]
Paul McJones. Meta APL Floating-Point Arithmetic. 13 June 1972. Design notes. 19720613-prm-meta_apl_floating_point_arith
[Mc1972b]
Paul McJones. Preliminary Reference Manual for the CRMS System APL Processor. Technical Document, Systems Group, Center for Research in Management Science, 12 July 1972. 19720712-prm-prelim_crms_apl_proc_ref
[Mc1973c]
Paul McJones. CRMS APL Processor Reference Manual. Technical Document, Systems Group, Center for Research in Management Science, 2 February 1973. 19730202-prm-crms_apl_processor_ref

Source code

[Mc1973a]
Paul McJones. APL\META4 Microcode. Digital Scientifc META 4 Series 16 assembly language. 28 January 1973. See also Appendix 3. 19730128-prm-crms_apl_proc_microcode
[Mc1973b]
Paul McJones. Test programs for CRMS APL Processor. NARP assembler for SDS-940. 18 December 1972; revised 8 January 1973. MACAPL: MACRO package for META-APL assemblies, facilitating creating programs to be executed by the CRMS APL Processor; TPFACT: Recursive factorial function; TPIDX: Exercise various index-related operations; TPREF: Exercise memory references; TPARITH: Exercise arithmetic. 19730128-prm-crms_apl_proc_tests

Software

Documents

[Re1972a]
David Redell. Interprocess Communication. Working Document, 20 July 1972. 19720720-ddr-interprocess_communication
[Re1972b]
David Redell. CRMS APL/SIMPLE Integrated Language Processing System: Design Considerations. 22 July 1972. 19720722-ddr-integrated_lang_sys
[Gre1973]
Mark Greenberg. SIMPLE Language Specification Reference Manual. Technical Document R1, Systems Groups, Center for Research in Management Science. 26 July 1973; revised 5 September 1973. 19730726-mlg-simple_lang_ref
[Xx197xa]
?. SIMPLE Interactive Language System Reference Manual. Cited by [19730726-mlg-simple_lang_ref] but no known copy. However see Language Services.
[Mc1972d]
Paul McJones. CRMS APL Syntax. 30 October 1972. 19721030-prm-crms-apl-syntax
[ReMc1972]
Dave Redell and Paul McJones. CRMS Process Synchronization Mechanism. 11 November 1972. 19721111-ddr_prm-crms_process_sync
[Re1972c]
David Redell. Language System: Interim Command Language. 5 December 1972. 19721205-ddr-lang_sys_interim_cmd_lang
[Re1973a]
David Redell. Preliminary Language System User Manual. 2 February 1973. 19730202-ddr-lang_sys_prelim_cmd_lang
[Re1973c]
David Redell. External and internal character codes. 13 September 1973. (Exernal character codes were ASCII; internal codes were "rotated ASCII": (code-32) mod 128.) 19730913-ddr-char_codes
[GeeEtAl1974]
Paul Gee, Wiley Greiner, Sheldon Linker, and David Redell. Writing Behavioral Experiments in CRMS APL: Programmer's Manual (Preliminary Version). Technical Document, Systems Group, Technical Document Center for Research in Management Science, University of California, Berkeley. July 15, 1974. 19740715-gee_et_al-writing_behavioral_experiments

Source code

[Xx1974a]
?. SIMPLE Interactive Language System source. SIMPLE source code. Undated, circa 1974. 1974000-xxx-simple_language_system_source
[Xx1974b]
?. APL Runtime Supervisor source. SIMPLE source code. Undated, circa 1974. 19740000-xxx-apl_runtime_supervisor_source
[Re1973b]
Dave Redell. Inverse Bowling Problem. SIMPLE source code for problem posed by Perlis and solved by Dijkstra at 1973 NATO Summer School at Marktoberdorf. 11 September 1973. 19730911-ddr-inverse_bowling_simple

Appendix 2: People

Appendix 3: Errors in APL processor microcode

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:

“Bug 1” (page 76)
If the APL processor was started up with an incorrectly formatted heap (a free list that loops back to its middle rather than to the starting point), it could loop forever, requiring a power reset to clear it. To deal with this, a counter was added to the code that searched the free storage list, so it would stop after 2^16 iterations.
“Bug 2” (page 14)
The wrong error number was generated for a particular error condition detected when the processor started up on a new APL process.
“Bug 3” (page 31)
The ACOPY function failed to generate a trap if given the address of a variable with an “undefined” value.
“Bug 4” (page 24)
When the reference count of a block of memory is decremented and becomes zero, it shouldn’t actually be written back to memory as a zero, since the FREE routine might trap for some reason. (The APL processor’s model is that if a trap occurs, the state of the processor must remain unchanged from the state at the beginning of the current instruction, to make it easy to restart after a trap.)