SIMPL-Q(ID:2318/sim042)

Systems implementation language

Country: us
- languages for us
- us/1978
Began: 1978
Published: 1978
- 1978
Sammet:MLT
- MLT
- MLT/1978
- MLT/us

Implementation of SIMPL-T for Nanodata QM-1, used to write the EASY OS.

Places

U Maryland College Park us A

EASY	=>	SIMPL-Q	Target language for
SIMPL-T	=>	SIMPL-Q	Implementation
SIMPL-Q	=>	SML	Macro language for

References:

Flink, Charles W., "EASY—an operating system for the QM-1" in Proceedings of the tenth annual workshop on Microprogramming 1977 , Niagara Falls, New York, United States pp: 7 - 14 view details Abstract: The Emulation Aid SYstem is a virtual machine monitor for the Nanodata QM-1 microprogrammable computer. The system is designed to provide the user with an interactive interface for the development and subsequent use of emulations on the QM-1. EASY provides integrated support for: 1) interactive control of multiple, concurrently resident, virtual computers implemented via emulation, 2) input/output from emulations (virtual I/O) to the various real peripherals of the QM-1, and 3) diagnostic displays for debugging of both the emulations and the software running on the emulated computers. EASY is implemented at three distinct levels: the majority of the system software is programmed in a high-level language (SIMPL-Q); this (service) software, in turn, executes on an emulated intermediate language machine (also called EASY); the EASY machine executes as the highest priority task under a microprogrammed operating system kernel (called TASK). Via EASY the user currently has access to several previously developed emulations. EASY is the host system for ongoing emulator development at the Navy's Dahlgren Laboratory. Extract: The System Programming Language SIMPL-Q
The System Programming Language SIMPL-Q
One of the first tasks in the design of EASY was the selection of a suitable hlgh-level programming language. The plan was to take a suitable language and extend it by means of the addition of a few new intrinsic functions and procedures. These "system programming" extensions were to include synchronization operators (TRIGGER, WAIT), emulation control (STASK for start task, KTASK for kill task), a clean, table driven I/O interface (SIO), and control over interrupt handling (ARM, DISARM a procedure as an interrupt handler for a given interrupt level)s These extensions were essential to the tasks intended for the systems language, therefore a language had to be selected that would readily accept these extensions. The other key requirements for the language were a) "structured" control for readability and reliability, b) good bit manipulation support (for flexibility in interfacing to varied target emulations), and c) good character string support (for display and command interpreting).
The SIMPL-T programming language was suggested as a workable base language for several reasons, First, SIMPL-T is the base language in which the SIMPL family of compilers is implemented. Therefore, an extended language based on SIMPL-T would be self-hosting, Secondly, the -T in SIMPL-T stands for transportable. SIMPL-T is the member of the SIMPL family whose compiler is specifically designed to support easy bootstrapping and extension. Third, SIMPL-T supports part word operations addressable to the bit as well as a full complement of character string operations. Finally, SIMPL-T had just been bootstrapped to the CDC 6600-6700 computer system located at the author's facility.
SIF~L-T supports a basic set of structured
programming control structures consisting of
1) IF...THEN...ELSE...END (ELSE clause optional),
2) WHILE...DO...END (with optional EXIT and EXIT
ll for escapes from nested WHILE loops), and
3) CASE...OF 111... 121... Zstring case designator>l.,. ELSE.~.END (ELSE
optional).
These basic control structures can be augmented by means of macros to support (for readability purposes) other popular forms such as REPEAT...UNTIL...END. All source input is free form, and further, statements are terminated by the Simple ~END ~, or by the occurance of another keyword. There are no semicolons or other special statement delimiters.
The language is procedure (PROC) and function (FUNC) oriented. Parameters are passed by reference or value and are fully type-checked~ Data types include characters, integers (36-bit 2"s complement), strings (of characters), and onedimensional arrays of each of the 3 scalar types mentioned. Logical and bit operations are performed on integers.
The language does not support BEGIN ... END block-structures. All variables declared within a PROC or FUNC are local to each invocation of that procedure and managed on a run-time stack. Variables declared outside (before) procedure declarations are global to that compile module~ The use of ENTRY and EXTERNAL declarations allow Zhe linking of global data items or procedures between independent compile modules.
A powerful feature of SIMPL-T is an efficient and effective macro capability. Two types of macros can be defined: "DEFINE" macros support the invention of new keywords and intrinsic functions with parameters (as alluded to above), "MACRO" declared macros support conventional (possibly conditional) macro substitutions. This limited but easy-to-use extensibility of the language has significantly added to the reliability and readability of system software developed for EASY. The structure of (and lowest level interface to) all common system tables is defined by macros resident on a common system macro library. All modules within the system are documented with the aid of "documentation macros" that enforce standard format and content on comments included as procedure or module headers.
The SIMPL-T language, once extended by the addition of the SYSTEM keyword and a number of lesser extensions, was renamed SIMPL-Q to distinguish this member of the SIMPL family as the System programming language for the QM-I Further discussion of SIMPL-Q can be found in [FLIN77, FLIN77A].
The syntax and semantics of SIMPL-Q provide the only firm architecture for the programmer. A SIMPL-Q programming reference manual is in preparation -3- that will form a concise and complete statement of the syntax and semantics of SI~L-T, the extensions added to support system programming, and the data structures of concern to programmers defined by the current EASY machine emulator, This one source is intended to be the only standard to which future implementations of SIMPL-Q are designed. This high-level specification defines the SIMPL-Q machine architecture. Strict adherance to these standards will allow lower level machine organization to evolve without loss of significant software compatibility.

Flink, Charles W., "SIMPL-Q—A System Programming Language for the QM-1," DK-74 internal report, NSWC/DL 1977. view details

Perry, John G., Jr. "SIMPL-Q Reference Manual." Naval Surface Weapons Center Dahlgren Lab Va Apr 78, 165p NSWC/DL-TR-3778 view details Abstract: The system described in this report consists of a system computer programming language (SIMPL-Q) and a simple macro language (SML). The SIMPL-Q compiler and SML execute on either the CDC-6700 under the SCOPE 3.4 operating system or on the Nanodata QM-1 under the EASY operating system. The code produced by the SIMPL-Q system is designed to execute on the Nanodata QM-1 EASY intermediate language machine. The SIMPL-Q language is a member of the SIMPL-T family of languages. SIMPL-T was designed and implemented on the UNIVAC 1108 by Dr. Victor R. Basili and Albert J. Turner of the University of Maryland. SIMPL-T is a transportable structured programming language with three basic data types: integer, character, and string. SIMPL-T was enhanced to allow it to be used as a system programming language for the Nanodata QM-1. This report is intended to be used as a reference manual. The report presents the details, rules, and examples for writing programs in the SIMPL-Q language. It also contains sufficient information to prepare and compile such programs.

Flink, Chuck "Sun Burns Java Standardization Effort" Flink Ink March 4th, 2000 view details Extract: History of VM
Now let me give you examples of previous "invention" of the Java Virtual Machine some seem to think is so new and creative.  I just pulled off my shelf the book:  Computer System Organization, by Elliott I. Organick.  It is one of the seminal books in the history of computer architecture.  It describes the Burroughs B5700/B6700 series of language-oriented computers, all designed around an architecture inspired by the Algol programming language.  The intent was to be an optimal blending of hardware architecture and compiler technology.  In the few years after this book, the B1700 was developed as the lowest cost member of the B*700 family.  While the high-end machines were based on an optimum match of the hardware to the target language, as proposed by Sun for the future "Java Chip", the B1700 was micro-programmed to emulate any of a family of language oriented virtual machines (VMs):  one designed for Algol, one designed for Cobol, another designed for Fortran, etc.  A micro-programmed OS time-shared the hardware between these multiple language oriented VMs, allowing the B1700 to simultaneously run programs written in each of these languages.

In 1976, I tried to buy a B1700 to develop an emulator of the Trident Missile fire-control computer under development at my Navy Lab.  Burroughs refused to allow us to micro-program a B1700 on the grounds that the technology was an important company secret.  We ended up with a Nanodata QM-1, emulated the as-yet-to-be-built Trident computer, allowing the compiler and OS developers to begin modular testing on schedule, even though development of the real hardware had slipped nearly a year.  Shortly after testing began, the OS developers discovered confusion between themselves and the hardware engineers that would have cost months and millions if not discovered so early.  The VM we built paid off well for the Navy.  Our success spawned research funding that allowed a couple of us to implement the Emulation Aid SYstem (EASY) and the Simpl-Q VM that shaped the next 5 years of our research.  EASY was an operating system written in Simpl-Q that functionally was the parallel to the B1700 micro-coded operating system.  It managed the sharing of the QM-1 hardware between multiple emulators, and itself was written in Simpl-Q and ran on an emulation of a VM designed to optimally support the Simpl-Q language in the context of our needs.

I describe this history not to make myself sound great.  This work turned out to only count as Masters Degree projects for me and John Perry.  (John built a code generator for the Simpl-Q compiler, generating the Easy-Q code-bytes that I interpreted in the VM.  I designed and built the OS and micro-coded VM, we jointly designed the byte-code architecture to make each of our jobs easier.  John got his MS from University of Maryland, I got mine from VPI&SU.)  How is it that less than a generation later, the Java VM is suppose to be such a revolutionary concept?