JOVIAL(ID:83/jov001)

Alphabet and Vocabulary

JOVIAL's alphabet is the FORTRAN alphabet of 48 signs consisting of 26 letters, 10 numerals, and a dozen miscellaneous marks including the blank, the prime, and the dollar sign. JOVIAL's symbols, which are delimiters, identifiers, and constants as in ALGOL, are formed of compact strings of these signs?compact in the sense of not containing arbitrary numbers of embedded blanks.

DELIMITERS

JOVIAL's delimiters are its verbs and punctuation and are similar to ALGOL delimiters. JOVIAL thus has its quota of separators, brackets, declarators, and arithmetic, relational, logical, and sequential operators ?and a set of file operators for describing input/output, a set of functional modifiers for manipulating machine symbols, and a set of descriptors for more elaborate data description, as well.

IDENTIFIERS

Identifiers are labels naming the elements of a JOVIAL program's information environment: statements; switches; procedures; items and arrays of items; tables; and files. Except for context defined statement names, all such labels must be declared, either in the program, or in a COMPOOL or system declaration list. A JOVIAL label consists of an initial letter followed by any string of letters and numerals, which may be punctuated for readability by the ' separator. Labels must therefore be two or more characters in length.

Examples:

U2
STEP1
FLIGHT?POSITION

CONSTANTS

JOVIAL programs manipulate four types of data: numeric data, in either floating or fixed-point representation; literal data, in either computer dependent Hollerith or standard Transmission code representation; status data; and Boolean data. Neither literal nor status values are handled by ALGOL and it is their inclusion in JOVIAL that allows it to describe its own compilation.

Constant numeric values

Constant numeric values may be denoted in JOVIAL by both decimal and Octal integers and by mixed decimal numbers, which may be suffixed by an Exponential scaling factor or by a (fixed-point) precision indication, giving the number of bits after the binary point.

Examples:

12
0(34) .5 6.7E-8A29

Literal values

Literal values, which are, literally, strings of JOVIAL signs, may be denoted in either of the two possible 6-bit-per-sign encodings or directly by octal integers. Examples:

27H(THIS IS A LITERAL CONSTANT.)
11T(SO IS THIS.)
O(060706103230)

Status values

Status values, which are qualitative or categorical in nature rather than numeric, are denoted by mnemonic names. Examples:

V( EXCELLENT) V(READY)

Boolean values

And finally, Boolean values are denoted, True by 1 and False by 0.

Comments

Comments, in JOVIAL, are bracketed by double prime quotes,

"FOR EXAMPLE, THIS IS A COMMENT."

and may be inserted, between symbols, anywhere in the program. This makes it possible to write JOVIAL in a prose style that resembles fluent, if rather spasmodic, English.

Clauses

Strings of JOVIAL symbols separated by arbitrary numbers of blanks, which may be omitted where this does not join a numeral/letter pair, form clauses: item descriptions, which describe values; variables, which designate values; and formulas, which specify values. JOVIAL, however, lacks the conditional expression of ALGOL 60, which effectively selects from a set of
variables or formulas that one associated with the first True Boolean formula in a corresponding set of Boolean formulas.

Item descriptions

In JOVIAL, the basic units of data are called items. All the
necessary characteristics of an item's value, such as its type and the format
and coding of the machine-symbol representing it, need be supplied only once,
in an item description. Examples:

Floating
fixed 10 "bits" Unsigned "integer, ranging from" 1 ... 1000
fixed 36 "bits" Signed 15 "fraction bits"
Rounded
Hollerith 16 "signs"
Status V(BAD)  V(POOR) V(FAIR)  V(GOOD) V(FINE)
Boolean

Literal values may be any length; however, multiple-precision fixed-point arithmetic, though intended, has not yet been
implemented by any of the JOVIAL compilers, so that fixed-point numeric values are effectively limited :o computer word size.

VARIABLES

Since items are the basic units of data in JOVIAL, they are
the principal variables. As in \LGOL, there are no limitations on the
complexity of subscripting numeric formulas, which are enclosed in the brackets
($ and $).

Examples:

ALPHA
BETA($T2$')
GAMMA($0,T2+13,BETA($T2-1$)+1,99*ALPHA$)

Although the item is normally the smallest unit of data in
JOVIAL, it is occasionally necessary to designate a value represented by part
of an item's machine-symbol, which may be considered a string of bits or, in
the case of literal items, of 6-bit bytes. This function is performed by the
subscripted functional modifiers BIT (operating on any item to designate an
unsigned, integral value) and BYTE (operating on a literal item to designate a
literal value.) Examples:

BIT ($FIRST/BIT,LENGTH$) (EMPLOYEE'CODE ($EMPLOYEE/NUMBER$))
BYTE ($9$).(MESSAGE)

FORMULAS

JOVIAL formulas are classified according to the type of
value they specify?numeric, literal, status, or Boolean. Though all the
operands in a formula must specify the same type of value, an individual
operand may be: a constant; a variable; or a function, specifying the value
computed by a procedure. Examples:

1.0E-4A15
BETA($T2$)
ARCSIN(BETA($T2$),1.0E-4A15

NUMERIC FORMULAS

The syntax of numeric formulas in procedure-oriented
languages is pretty well standardized. JOVIAL, however, is distinguished by a few
minor differences, which bear mentioning: multiplication and exponentiation are
signified by * and **, as in FORTRAN; absolute magnitude is signified by the
brackets (/ and /); negation may be applied to any operand in a numeric
formula, taking precedence over all other operations; fractional or mixed
exponents are possible, although any exponentiation yielding a complex * root
as undefined; there is no integer division operator, as signified by -f- in
ALGOL 60; conversion between fixed and floating-point representation is
automatic, where necessary. Other than these, numeric formulas in JOVIAL follow
the standard conventions and produce the expected results, although the
programmer is occasionally advised to keep an eye on the precision resulting
from fixed-point arithmetic. Example:

(27*ALPHA($0$) + (/BETA($T2$)/)** - ARCSIN(BETA($T2$),1.0E-4A15))/1.889E-6A30

LITERAL AND STATUS FORMULAS

Both literal and status formulas specify the value expressed
by a single operand. Examples:

BIT ($FIRST/BIT,LENGTH$) (EMPLOYEE'CODE ($EMPLOYEE/NUMBER$))
BYTE ($9$).(MESSAGE) 

BOOLEAN FORMULAS

A Boolean formula specifies True or False, computed from the
values of its operands: Boolean constants, variables, and functions; and
relational formulas, a further type of Boolean operand containing relational
operators. Although relational operators signify primarily numeric relations
(EQ, is EQual to; NQ, is uNeQual to; GR, is GReater than; LQ, is Less than or eQual
to; LS, is LesS than; GQ, is Greater than or eQual to) they may also be used to
compare literal and status values on .the basis of their numeric encoding.
Unlike ALGOL, JOVIAL permits multi-relation formulas (for numeric and literal
values), which specify True only when all the indicated relations hold. This is
convenient for such things as determining whether a value lies within a given
range. Examples:

INDICATOR
LEGAL  (SIGNAL)
WEATHER($AIRBASE$) EQ V(FAIR)
lT(A) LQ BYTE($COLUMN$) (MESSAGE) LQ lT(Z) 

 

The logical operators AND, OR, and NOT may be used to
combine Boolean operands into- a complex Boolean formula. JOVIAL lacks,
however, logical operators for implication and equivalence, as found in ALGOL:
Example:

INDICATOR AND NOT  (WEATHER ($AIRBASE$)  EQ V(FAIR)  OR LEGAL
(SIGNAL))

SENTENCES

Delimiters and clauses combine to form statements, which
assert actions to be performed, and declarations, which describe the
information environment of the actions. These are the sentences of both JOVIAL
and ALGOL. Simple JOVIAL sentences are invariably terminated by the $ separator.

BASIC DECLARATIONS

In JOVIAL, single values (other than those denoted by
constants or used only as intermediate results) must be declared as items. The
ITEM declaration corresponds to ALGOL'S type declarations but it may not be
used, as they are, to define more than one identifier.

A MODE declaration initiates a normal mode of item
description for the implicit declaration of all subsequently referenced and
otherwise undefined and unsubscripted items. ALGOL has no counterpart to this
declaration, which JOVIAL borrowed from MAD, the University of Michigan
Algorithm Decoder.

Rectangular arrays of any dimension may be declared in
JOVIAL by listing the size of each dimension after the array item name in an
ARRAY declaration. JOVIAL's ARRAY declaration is considerably less
sophisticated than its counterpart in ALGOL 60, which allows the programmer to
specify a subscript range for each dimension (always 0 thru dimension-size ? 1
in JOVIAL) in terms of numeric formulas whose values may vary at run time, thus
implying dynamic storage allocation for arrays. Examples:

ITEM P66 Floating $
ITEM TALLY fixed 10 Unsigned 1..1000 $
MODE fixed 36 Signed 15 Rounded $
ARRAY CARD 80 Hollerith 1 $
ARRAY TICTAC'TOE 33 Status V(EMPTY) V(NOUGHT) V(CROSS) $
ARRAY LINE 7 5 120 Boolean $

Named and compound statements

Any JOVIAL statement ? simple, compound, or named ? may be
given a name, which is separated from the statement that follows by the . separator;
and any list of statements, which may be interspersed with declarations, can be
grouped into a single, compound statement with the brackets BEGIN and END.
JOVIAL lacks the "block" concept of ALGOL 60, where identifiers
declared inside a compound statement are undefined outside it and thus may be
used for other purposes.

Basic statements

The basic statements of both JOVIAL and ALGOL are similar in
effect, but differ slightly in syntax. A JOVIAL assignment statement, however,
cannot assign a value to more than one variable, as can an ALGOL 60 assignment
statement, and ALGOL lacks the exchange or double assignment statement of
JOVIAL, which is signified by the ==: separator. GOTO statements are the same
in both, languages, but JOVIAL retains both the IF statement and the IFEITHer -
ORIF alternative statement of ALGOL 58, which has since been replaced in ALGOL
60 by the equivalent and more general if? then ?else conditional statement.
Examples:

TALLY == COUNT $
     IFEITHer TALLY GR 0 $ TALLY = TALLY*2 $
          ORIF TALLY LS 0 $ TALLY - TALLY/2 $
          ORIF 1 $ TALLY = 1 $ END
     IF 60 LQ TEMPERATURE ($AIRBASE$) LQ 90
     AND VISIBILITY ($AIRBASE$) GR 3 "miles" $
     WEATHER ($AIRBASE$) == V(FAIR) $
     GOTO PREDICT $

FOR statements and subscripts.

A JOVIAL FOR statement activates a subscript (which is an
intrinsic, integer-valued variable identified by a single letter), assigns it
an initial value, and causes the next (non-FOR) statement listed to be
repeatedly executed one or more times. As in ALGOL, a JOVIAL FOR statement
includes an initial-value formula, an increment formula, and a limit value
formula but lacks the Boolean while formula of ALGOL 60 and may not include
more than one sequence of formulas. JOVIAL is also limited since its loop
parameter is an integer-valued variable that is undefined outside its loop,
while an ALGOL loop parameter may be any arithmetic variable. JOVIAL has the
advantage, however, of allowing the omission of the limit value formula in a
FOR statement, thus creating a loop without an implicit termination test, and
also of allowing any number of these shortened FOR statements after a complete
FOR statement, creating a multi-parameter loop, with one controlling parameter
and many non-controlling parameters, all of which are incremented each
repetition. Example:

ARRAY NODE 25 25 Floating Rounded $
          TRANSPOSE. BEGIN
               FOR I = 0,1,24 $
                    BEGIN
                    FOR I = 0,1,24 $
                    NODE($I,J$) ==
                    NODE($J,I$)  $
               END   END

Table declarations.

A table is a matrix of item values whose columns are linear
arrays and whose rows, called entries, are therefore related sets of different
items. Typically, entry K (NAME1 ($K$),.- - -, NAMEn($K$)) would designate
values measuring the n pertinent attributes of "object" K. A table's
entries all have the same composition since each consists of a similarly named
and ordered set of items declared within the BEGIN and END brackets after the
TABLE declaration.

TABLE PAYROLL  Variable "length" 1000 "entries maximum" Dense "packing" $
          BEGIN
     ITEM EMP'NAME   Hollerith 18 $
     ITEM EMP'CODE   fixed 12 Unsigned $
     ITEM PAY'RATE     fixed 10 Unsigned $
     ITEM YTD'EARN    fixed 24 Unsigned $
          END

The JOVIAL programmer also has the ability to declare: tables with entry structures like those of previously declared tables; tables with entries for which storage allocation is completely specified; and tables with entries composed of variable length item-strings, rather than single items.

Tables are the important data structures in most JOVIAL programs, so the language provides three functional modifiers to aid their manipulation: NENT (for Number of ENTries), which allows this unsigned, integral value to be designated for Variable length tables and specified for Rigid length tables; ALL, which creates a loop to cycle through an entire table when used in an abbreviated FOR statement; and ENTRY, which allows an entry to be considered a single value, represented by a single, composite symbol. Example:

FOR I = ALL (PAYROLL)  $
     "Eliminate empty entries?
          BEGIN  SEEK'EMPTY.
          IF ENTRY(PAY'ROLL )($!$)) EQ 0 $
               BEGIN
               NENT( PAY'ROLL) = NENT(PAY7 ROLL) - 1 $
          IF ENTRY (PAY'ROLL )($!$)) EQ 0 $
               BEGIN
               ENTRY (PAYROLL ($NENT(PAY'ROLL) $)) == ENTRY (PAYROLL.($!$)) $ GOTO SEEK'EMPTY $
     END END END

MISCELLANEOUS DECLARATIONS AND STATEMENTS.

The JOVIAL OVERLAY declaration names sets of items, arrays,
and tables that must share a common memory block. Each such set thus
"overlays" the other sets listed in the declaration. In contrast,
ALGOL 60's own declaration lists those environment elements that must not be overlayed.

In JOVIAL, though not in ALGOL, it is possible to declare
items with specific initial values. For simple items, this may be done by
inserting, into the item declaration, the descriptor Preset followed by the
desired constant. Array and table items, however, are initialized by arrays of
constants, listed immediately after the declaration.

The JOVIAL DEFINE declaration establishes an equivalence
between a label and an arbitrary string of signs by effectively causing the
sign string to be substituted for the label wherever it may subsequently occur.
This allows the programmer to abbreviate lengthy expressions, to make simple
additions to the language, and to create symbolic parameters ? functions no
"higher-level" programming language should lack, though most of them
do.

The JOVIAL CLOSE statement is a closed and parameterless
subroutine removed from the normal sequence of statement executions and invoked
only by a GOTO statement (which may be a switch call). Its normal successor is
the statement listed after the invoking GOTO statement.

A DIRECT statement allows the inclusion of a routine coded
in a machine-oriented programming language. This routine, enclosed in the
brackets DIRECT and JOVIAL, may set and use JOVIAL items.

JOVIAL also includes: a TEST statement, which terminates the
iteration of a loop; a RETURN statement, which terminates the execution of a
procedure or a closed statement; and a STOP statement, which terminates the
execution of a program. The TEST and RETURN functions are performed in ALGOL 60
by go to statements.

Switches

Two kinds of switches may be declared in JOVIAL:  indexed switches, which are similar to those in ALGOL; and item switches, which have no direct ALGOL counterpart. The numeric formula subscripting the name of an indexed switch indexes the list of statements or switch calls given in the SWITCH declaration, while the numeric formulas that may subscript the name of an item switch index the item name given in the SWITCH declaration and thus designate an item value that is -compared for equality with a list of constants, also given in the declaration, to select one from a corresponding list of statement names or switch calls. In either case, the failure of a switch to compute a statement name effectively specifies the name of the statement after the GOTO statement invoking the switch. Examples:

GOTO STEP($K-1$)
     SWITCH STEP = (STEP1,STEP2,STEP3, , STEPS, STEP6) $
     SWITCH BRAND (WEATHER) = (V(STORMY) = MAINTAIN'SUMMARIES, V(CLOUDY) = STEP ($STATION-1$),V(SUNNY)=STEP4)  $

Procedures

A procedure, which is a self-contained computation with a fixed and ordered set of formal parameters, is invoked by a procedure statement or a function call. Calling parameters in JOVIAL are either: values, as specified by input formulas and as designated by output variables; or arrays, tables, or statements, as indicated by name. Formal parameters corresponding to calling parameter values must be declared as items within the procedure, and those corresponding to arrays and tables must be declared as such to provide the procedure with a fixed definition of their structure. The procedure itself is executed as though its formal parameters either designated calling parameter values, or were replaced with calling parameter names.

JOVIAL uses the ALGOL 58 convention of separating input parameters from output parameters by the = separator. As in ALGOL, identifiers declared inside a JOVIAL procedure are defined for the procedure only; and for a JOVIAL procedure to specify a function value, its name, considered as the sole formal output parameter, must be declared as an item within the procedure. Although JOVIAL procedures may invoke other procedures, they may not, either directly or indirectly, invoke themselves ? as is possible with ALGOL 60 procedures. Furthermore, they lack ALGOL's complete call-by-name facility, since a parameter that is a name provides a JOVIAL procedure only with a memory address, and not a structure. Example:

PROCedure WORDSORT  (WORD,LENGTH= ERROR)  $
     "A procedure that sorts a given length list of 5-character words into alphabetic order?
     ARRAY WORD 0 Hollerith 5 $
     ITEM LENGTH fixed 15 Unsigned $
     ITEM ERROR Boolean $
               BEGIN
               ERROR = LENGTH LS 2 $
               IF ERROR $ RETURN $
          FOR I = 0,1, LENGTH - 2 $
               BEGIN
               IF WORD($I$) GR WORD ($1+1$) $
                    BEGIN
                    WORD($I$) == WORD ($1+1$) $
                    FOR J =I,-1 $
                         BEGIN
     IF J EQ 0 OR
          WORD($J$)  GQ WORD ($J-1$)  $
          TEST 1$
          WORD($J$) == WORD($J-1$) $
                         END    END    END   END

Input/output and files

To allow reasonably efficient and computer-independent description of input/output processes in JOVIAL, all data entering or leaving the computer's internal memory is organized into files. A JOVIAL file is a string of records, which are themselves strings ? of bits or of 6-bit Hollerith coded bytes. In general, records are composite symbols, which may represent entire groups of values when stored within the computer's internal memory.

A file is activated by the execution of an OPEN INPUT or OPEN OUTPUT statement, and deactivated by a SHUT INPUT or SHUT OUTPUT statement. Active files may be both written and read, one record per transfer, although some files are read-only or write-only depending on the external storage device involved. An INPUT statement initiates a read operation, which transfers a record from the file into memory so as to represent a designated value or group of values, and an OUTPUT statement initiates a write operation, which transfers the record representing a specified value or group of values from memory out to the file. The index of the record currently available for transfer to or from the file is designated with the file-position functional modifier POSition, and ranges from 0 (indicating "rewound") thru number-of-records (indicating "end-of-file"). The transfer of a < record to or from a file automatically increments file position by one and, where the storage device allows, file position is a variable that may be altered by the assignment of an arbitrary value. The file is then called an "addressable" file, as opposed to a "serial" file where such a general positioning operation is to be avoided as impossible or inefficient.

Files are declared either binary or Hollerith in type, and associated with each file is a set of status constants denoting the possible states of the storage device containing the file. File status may thus be determined with a relational Boolean formula wherein the file name is considered as a status variable that is automatically updated prior to comparison according to the'' current state of the file's storage device. Example:

SORT'LEXICON'LISTS. "A routine to sort the word lists in a lexicon, using the WORDSORT procedure above." BEGIN
   FILE LEXICON Hollerith 1000." records
   Maximum?Rigid?record length of"
   500"bytes?V(INACTIVE) V(READY) V(BUSY) V(ERROR) DRUM'2000 $
   ARRAY LIST 100 Hollerith 5 $
   ITEM TROUBLE Boolean $
   OPEN INPUT LEXICON $
   READ. INPUT LEXICON LIST $
   READY. IF LEXICON EQ V(READY) $
        BEGIN
          POSition  (LEXICON)   = POSition (LEXICON) - 1 $
          WORDSORT  (LIST,100 = TROUBLE) $
          OUTPUT LEXICON LIST $
          GOTO READ $
          END
   IF LEXICON EQ V(BUSY) $
          GOTO READY $
          IF TROUBLE OR LEXICON EQ V(ERROR) $
          GOTO CORRECTION $
          SHUT OUTPUT LEXICON $
          END 

JOVIAL lacks a FORMAT declaration (as found in FORTRAN, for example) and with it the ability of most business compilers to automatically insert, in programs, input editing and report writing routines. Although this lack is JOVIAL's main weakness as a practical programming language, it can be partly remedied with library procedures.

Programs

A JOVIAL program is a list of declarations and statements enclosed in the brackets START and TERM and followed by the $ separator, which indicates the typographic end of the program. The name of the first statement to be executed may be' inserted after the TERM; otherwise it is the first statement listed that is not part-of a procedure.

Evaluation

Both JOVIAL and ALGOL, it seems, were designed by committees, but JOVIAL's poly-parentage is the more painfully apparent; it is not as "pretty" a language as ALGOL. For all its minor notational flaws, however, JOVIAL is a much more useful programming tool. It includes as much of ALGOL'S capabilities as do most ALGOL compilers (which tend to omit the hard parts) and further capabilities as well, permitting JOVIAL compilers to be written in JOVIAL. In addition, though JOVIAL can be quite cryptic in the hands of programmers uninterested in readability, it is very easy to write JOVIAL programs that can be read by non-programmers. In this respect, though no claim is made that JOVIAL programs can be written by non-programmers, JOVIAL compares favorably with COBOL. In short then, JOVIAL is probably as powerful a tool for systems programming as exists today.

Summary of The Development of JOVIAL

Con Rodi

CS 5314

Beginnings

In late 1958, the ACM published a description of the International Algebraic Language (IAL, now called ALGOL), and the Air Force launched a large command and control system called SACCS. SAGE, the largest real-time system to date, had just been completed in assembly language. It and IAL served as the basis for the new programming language JOVIAL. Jules I. Schwartz and others recommended to develop a high-level language to build SACCS. Schwartz wrote that the Development of JOVIAL to serve as a “sort of permanent record of the language.” Though not developed singly by Schwartz,  the language is named after him. OVIAL, or “Our Version of the International Algebraic Language” had a connotation to the birthing process, so it was renamed JOVIAL, or “Jules’ Own Version of the International Algebraic Language” during its early stages of development.

The language was designed in parallel to its two compilers, the AW/FS Q-31 and 709, since the emphasis on the language was to develop the compilers for use for the SACCS development. The compilers themselves were written in JOVIAL (The first JOVIAL compilers may have been the first compilers written in the language they where to compile.) Documentation for the language was not published until after major portions of the compilers were written.Versions include J0, J-1, J1, J2, J3, and later J3B, J4, J5, J5.2. Other experimental versions where JX2, Basic JOVIAL, JX2, and TINT. CORAL, SYMPL, SPL, CMS II and perhaps PL/I were influenced by the language. Finally, in 1973, a new standard version (J73) was produced, the version that is still in use today.

Objectives

The original major objective for JOVIAL was to use it for programming large systems. This required a flexible language.  Things ignored were compiler speed, language elegance, and standardization. This was a direct result of the fact that language features were added as needs were realized.In fact, the paper gives the example that the Data Definition capability was designed in 30 minutes.Originally I/O and exception handling were left out of the language. I/O was added later as subroutines.

Most of the major language features were taken from IAL.This included syntax; compound statements; major operators; statement structure, labeling and ending; procedure calls, and loop structures. There were a few major additions or changes.The first is the Data Definition area.The lowest data description level is the item.This could be one of multiple types (floating point, fixed point, character strings, and status values). Groups of items were placed in an entry, an abstraction of a particular object (a Person for example).Entries then were put into tables, the highest level of object abstraction.This was set up to define data structures and to achieve the capability of access to the data without having to know where the data was kept in the items and entries. Therefore, changes could be made in the data description independent of the JOVIAL program, for the most part.

Another major feature is access to bits and bytes of items (keywords BIT and BYTE) and access to entries in tables. With the LOC keyword, a table or item can be referenced, similar to pointers in modern languages.With this the designers also added the capability to insert machine language into a program through the keywords DIRECT <machine language> JOVIAL.

Conclusions

As stated earlier, many of the design decisions for language features where made as they were needed. This resulted in a sometimes-awkward syntax.  Since there were no tutorials made, the language was hard to learn, but once beginners learned the language, they hardly had any questions because the language was practical.

JOVIAL was originally intended to be written on one computer and run on many different computers, but as time went on, many of the compilers were written to take advantage of the computer it was written on, leading to many incompatibilities and subsets of JOVIAL. The flexibility and generality of the language led to a move away from portability. JOVIAL met its objectives as exemplified by the many systems produced in the language (even still today) by the FAA, Air Force, Navy, and others.

Bibliography

Schwartz, Jules I. "The Development of JOVIAL." SIGPLAN Notices
13.8 (1978): 203-214.  

• Discussion of Compool on alt.folklore.computers
  external link
• Discussion of JOVIAL origins on on alt.folklore.computers
  external link
• Jovial on alt.folklore.computers
  external link