JOVIAL

JOVIAL is the high-level language used to program the 9020 NAS system's ATC applications. This page covers JOVIAL material specific to the 9020. Whilst "standard" JOVIAL was available in several dialects, such as the J2 dialect on which it was based, NAS used a specific version called IBM 9020 JOVIAL. The enhancements to J2 are briefly mentioned below and fully described in the linked User’s Manual. The JOVIAL compiler ran under NOSS, which itself could run on a 9020 or a standard S/360. Similarly, compiled JOVIAL programs could run on either type of system.

Excerpt from THE HISTORY OF JOVIAL - Michael Hogan - 1983

Use of 7090 J2 Compiler

"The use of JOVIAL for the NAS system began in 1962 when the FAA established the National Aviation Facilities Experimental Center (NAFEC) near Atlantic City, NJ, to study the feasibility of automating the existing air traffic control system. NAFEC used an IBM 7090 computer connected to various peripheral devices to provide a test bed for the proposed automated system.

Wishing to avoid programming the 7090 in assembly language, NAFEC began looking for a suitable high-level language when they heard of JOVIAL, a then new language developed by the System Development Corporation (SDC). In April 1962, NAFEC received a complete set of 7090 JOVIAL J2 documentation, which confirmed that it, alone among the high-level languages then available, had the needed features for describing at the bit level the many I/O message formats needed to interface with the peripheral devices NAFEC was using. Also, SDC had a working compiler. A month later NAFEC received a deck of cards containing the 7090 J2 compiler in object format from Jules Schwartz at SDC.

From May 1962 until March of 1963, the FAA and IBM Federal Systems Division, which was the NAFEC support contractor, used the J2 compiler to develop experimental air traffic control programs for the proposed system. This effort was very successful. The use of JOVIAL allowed code to be written both by FAA air traffic controllers with very little programming experience and by IBM people with little or no 7090 experience.

In November 1963, with the feasibility of an automated air traffic control system assured, the FAA issued an RFP for the NAS. IBM was one of the potential contractors for NAS. In preparing their proposal, the question of the language to be used came up. PL/I (called NPL at that time) and JOVIAL were the languages being considered. In December 1963, Dave Ketchum, an IBM language expert, strongly recommended the use of J2 because of previous FAA experience with JOVIAL at NAFEC and because PL/I did not have a firm definition at the time. IBM proposed the use of JOVIAL. In June 1964, the NAS contract was awarded to IBM."

The IBM 9020 Compiler.

"IBM's design for the NAS system was based on the new IBM 9020 computer. The 9020 was a multiprocessor version of IBM's then new System 360. The first 9020, the 9020A, was not delivered until the end of 1965 and consisted of three input/output control elements and four central processing units (CPUs), each of which was essentially a 360/50 computer with I/O and memory removed. Core memory was in separate elements equally accessible to all active CPUs and I/O control elements. The 9020A was later replaced by the 9020D based on the 360/65 CPU.

Because of the long lead time to build the compiler, IBM contracted the Computer Usage Company (CUC) to begin building a J2 compiler for the IBM 9020 in January 1964. This compiler was to have the same capabilities as the SDC J2 7090 compiler. Until the 9020 became available, all compiler development was done on the IBM 7090 using an IBM built assembler and simulator for the IBM 360, which had the same machine instruction set as the 9020. As the compiler grew in size, the simulation time on the 7090 grew too slow, and CUC began using the IBM 7030 supercomputer (nick-named STRETCH) for simulation. Even the STRETCH was slow: the J2 compiler required about an hour to compile a 100-statement program under simulation!

The compiler was delivered to IBM in September 1965. It translated J2 into 360 Basic Assembler Language (BAL), which was then assembled into machine code. The compiler was not constructed using SDC's approach with a separate front end and code generator. Instead, the compiler was divided into four phases, each of which translated its part of the JOVIAL source program directly into BAL. This monolithic design coupled with the fact that the compiler itself was written in 360 assembly language made the compiler virtually impossible to retarget or rehost.

After delivery of the compiler, IBM made several enhancements. The compiler was optimized by using the special BAL byte-manipulation instructions for character manipulation, which CUC had not used. Later, major features such as pointers were added. After a few years, the compiler recognized a version of JOVIAL that was very different from the original version of J2 and that was referred to as IBM 9020 JOVIAL. Thus, another variation of J2 was introduced.”

The IBM 9020 JOVIAL Compiler

The are 74 source files that generate the NOSS tape, 22 of which appear to be directly JOVIAL-related. These files are listed on the right. SPT stands for Symbolic Program Tape.

The compiler is documented in the IBM/FAA Programming Project Office's IBM 9020 Data Processing System JOVIAL Language Reference Manual and IBM 9020 JOVIAL Language User's Manual, Contract FAA-64-WA-5223, Atlantic City, NJ (August 1968).

Unfortunately, I haven't been able to locate a copy of either of these manuals. If you know of one, please see here.

However, I do have a later version of the User’s Manual from the year 2000. The IBM 9020 was replaced by an IBM 3083 system running MVS. This later manual is a rewrite to reflect this change, but I very much doubt that the core JOVIAL commands, etc., changed at all. Find it here.

Below, by way of an example, are the first few lines from a listing of the main JOVIAL compiler subprogram source code JOV.SPT. All the source code files are available in the two zip files NOSS1.ZIP and NOSS2.ZIP. Note that this is the source code of the JOVIAL compiler and is written in S/360 Basic Assembly Language for processing by the BALASM subprogram. See further below for an example of actual JOVIAL code.

JOV APROG 00001000

0300 TITLE 0300 J O V JOVIAL COMPILER COORDINATER 00002000

JOV START X'D000' 00003000

SPACE 3 00004000

* COMPILER COORDINATOR 00005000

*THE COMPILER COORDINATOR IS A GROUP OF LOOSELY KNIT SUBROUTINES 00006000

*WHICH PERFORM THE FOLLOWING FUNCTIONS 00007000

* 1. INITIALIZE THE SYSTEM PRIOR TO START OF COMPILATION 00008000

* 2. BETWEEN EACH PHASE WRAPS UP PRIOR PHASE AND BRINGS IN NEXT 00009000

* 3. BLOCKS OUTPUT RECORDS GOING TO .WORK2 OR .WORK3 00010000

* 4. UNBLOCKS INPUT RECORDS COMING FROM .WORK2 OR .WORK3 00011000

* 5. AFTER PHASE 3, DETERMINES IF ASSEMBLY IS TO BE PERFORMED. 00012000

* IF SO, RETURNS TO JOB CONTROL INDICATING COMPILATION SUCC- 00013000

* ESSFUL. IF NOT, PRODUCES DIAGNOSTIC LISTING ON .OUTPUT 00014000

SPACE 3 00015000

*THE FOLLOWING LIST OF EQUATES DEFINES LOCATION OF FIELDS USED IN THE 00016000

*COMMUNICATION AREA 00017000

* 1. CRFLAG - COMPILATION SUCCESSFUL OR UNSUCCESSFUL 00018000

* 2. CRMSIZ - MACHINE SIZE 00019000

* 3. CRPHAS - NAME OF PROGRAM FOR SYSTEM LOADER TO READ IN 00020000

* 4. CRSWS3 - PUNCH SYMBOLIC DECK SWITCH 00021000

* 5. CRSWA - COMPOOL ATTACHED SWITCH 00022000

SPACE 1 00023000

CRFLAG EQU X'4F0' 00024000

CRMSIZ EQU X'5F0' 00025000

CRSYAS EQU X'5F4' 00026000

CRPHAS EQU X'4F6' 00027000

CRSWS3 EQU X'4F3' 00028000

CRSWA EQU X'68B' 00029000

CRASS EQU X'5FC' 11232 00030000

LIFLC EQU 64 CMS 00031000

SPACE 3 00032000

*THE FOLLOWING LIST OF EQUATES DEFINES THE LOGICAL UNITS ASSIGNED TO 00033000

*THE SYSTEM TAPES 00034000

SPACE 1 00035000

IOD01 EQU 04 00036000

IOD02 EQU 5 CMS 00037000

IOD03 EQU 06 00038000

IOD04 EQU 09 00039000

IOD05 EQU 10 00040000

IOD06 EQU 11 00041000

IOD07 EQU 07 00042000

SPACE JK 00043000

EJECT 00044000

*COMPILER COORDINATOR COMMUNICATIONS REGION 00045000

*CONTAINING INTERPHASE ADCONS AND SWITCHES 00046000

*AND TABLE CONTROL WORDS 00047000

* 00048000

*THIS REGION IS PERMANENTLY COVERED 00049000

*BY REGISTER 15 WHICH CONTAINS THE ADDRESS OF ZCON. THIS REGISTER 00050000

*IS LOADED DURING BEGIN COMPILATION AND REMAINS LOADED TO END OF JOB. 00051000

SPACE 3 00052000

DS 0F 00053000

ZCON EQU * 00054000

ZTITLE DC CL8' ' NAME OF SOURCE PROGRAM 00055000

ZADDR DC CL8'0 ' ASSEMBLY START ADDR FROM START CARD JMH 00056000

ZGENCT DC F'0' GENERATED LABEL COUNTER 00057000

ZTRAN DC A(USTART) LOAD ADDR OF PHASE OVERLAYS J C2641 00058000

* JMH 00059000

* JMH 00060000

ZBKNO DC F'0' BLOCK NO. TO ASSIGN TEMPS. 00061000

ZBKLOC DC F'0' NO. OF BYTES OF DATA RESERVED 00062000

ZBKLIM DC F'0' NO. OF BYTES OF DATA IN CURRENT 00063000

* BLOCK 00064000

ZF1A DC CL6' ' NAME OF TABLE THAT OVERFLOWED 00065000

* IN PHASE 1A 00066000

ZXSES EQU ZF1A+4 EBCDIC NBR OF SE'S FOR JV C2601 00067000

* PHASE 1 PAGE HEADER JV C2601 00068000

ZPCODE DC X'0000000000' INDICATOR FOR PLACING PROCESS 00069000

* ITEMS ON .WORK1 AS COMMENTS 00070000

ZFATSW DC XL1'0' SWITCH INDICATING A FATAL DIAG. 00071000

* IF 0, NO FATAL. IF 1, FATAL 00072000

ZPHASE DC XL1'0' SWITCH INDICATING PHASE IN PRO- 00073000

* GRESS 00074000

* IF 1, PHASE 1. IF 2, PHASE 1A. 00075000

* IF 4, PHASE 2A. IF 8, PHASE 2D. 00076000

* IF 10, PHASE 3. 00077000

* X'20' BIT - SPECIAL SUPPRESS ZPUT JMH 00078000

ZSER DC XL1'0' SWITCH INDICATING A SERIOUS DIAG 00079000

* IF 0, NO SERIOUS. IF 1, SERIOUS 00080000

ZSTART DC XL1'0' SWITCH INDICATING OPTIONS CHOSEN 00081000

* ON JOVIAL START CARD. 00082000

* 80 - COMPOOL IN USE DYBUF 00082100

* 40 - CLOSE ON START CARD DYBUF 00082200

* 20 - LIBE ON START CARD DYBUF 00082300

* 10 - LINKABL ON START CARD DYBUF 00082400

* 08 - REENT ON START CARD (WITH LIBE,LINKABL) DYBUF 00082500

* 04 - UNUSED DYBUF 00082600

* 02 - UNUSED DYBUF 00082700

* 01 - UNUSED DYBUF 00082800

ZXSTRT EQU ZSTART DYBUF 00082900

ZXOPTNS DC XL1'0' OPTIONS ON $JOV, START, AND .CNTRL CARDS C2806 00083000

* X'01' = PUNCHS ($JOV) C2806 00084000

* X'02' = BLKDATA (START) C2806 00085000

* X'04' = RESERVED C2806 00086000

* 08 - ASSEMBLE (PREV ZSTART X'10' BIT) DYBUF 00086100

* X'10' - TITLE CARD PRECEDED START 06152 00086200

* X'04' STRUCTURED LISTING S-054 00086300

EJECT 00087000

* 00088000

*TABLE CONTROL WORDS - PRESET FOR 256K BYTE MEMORY 00089000

* 00090000

*EACH THREE WORD PACKET CONTAINS THE FOLLOWING INFORMATION 00091000

* WORD 1 BEGINNING ADDRESS OF THE TABLE AREA 00092000

* WORD 2 CURRENT ADDRESS OF THE TABLE AREA - NEXT AVAILABLE 00093000

* WORD 3 ENDING ADDRESS OF THE TABLE AREA - LIMIT PLUS 1 00094000

SPACE 3 00095000

ZXSEG DC A(SEG,SEG,STATEC-4) JMH 00096000

ZSTATE DC A(STATEC) STATUS CONSTANT 00097000

DC A(STATEC) 00098000

DC A(ITEMEQ-8) 00099000

.

DCON69 DC 24F'0' READ AREA FOR COMP HEADER 0804X 03890000

END JOV C2641 03891000

Here is a short program written in the JOVIAL language:

0001 START MEAN "MAIN PROGRAM MEAN"

0002 TABLE SEARCH R 10 1$ "TABLE SEARCH HAS TWO ITEMS"

0003 BEGIN

0004 ITEM ARG I 16 U 0 0 D $

0005 BEGIN

0006 2 0 10 9 80 60 90 44 55 20 "INITIAL VALUES"

0007 END

0008 ITEM FOUND I 16 U 0 16 D$

0009 END

0010 TABLE COUNT R 100 1 $ "TABLE COUNT HAS TWO ITEMS"

0011 BEGIN

0012 ITEM ADD I 16 U 0 16 D$

0013 BEGIN 1 END

0014 ITEM SQR I 16 U 0 0 D$

0015 END

0016 ITEM TOT I 32 S$ "SINGLE ITEMS"

0017 ITEM DEV I 32 S$

0018 ITEM AA I 32 S $

0019 ITEM BB I 32 U$

0020 ITEM CC I 32 U$

0021 ITEM DD I 32 U$

0022 A01. TOT =0$ "FIRST OPERATIVE STATEMENT"

0023 DEV= 0$

0024 FOR A= 1,1,NENT(COUNT)— 1$ "FOR STATEMENT"

0025 ADD($A$) =ADD($A— 1$) + 1$

0026 FOR A= ALL(COUNT)$ "EQUIVALENT TO CARD 0024"

0027 TOT =ADD($A$) + TOT$

0028 TOT= TOT/NENT(COUNT)$

0029 FOR A = ALL(COUNT)$

0030 BEGIN "BEGIN RANGE OF FOR"

0031 AA= TOT —ADD($A$)$

0032 AA=AA(*2*)$

0033 SQR($A$) =AA$

0034 DEV= DEV+ AA$

0035 END "END RANGE OF FOR"

0036 FOR A=0,1,NENT(SEARCH)-1$

0037 BEGIN "BEGIN FOR RANGE FOR A"

0038 IF ARG($A$) LS ADD($0$) OR ARG($A$) "COMPLEX IF"

0039 GR ADD($NENT(COUNT)-1$)$

0040 BEGIN "BEGIN TRUE EXIT"

0041 FOUND ($A$) = 0$

0042 TEST A$ "TO FOR END FOR A"

0043 END

0044 AA=NENT(COUNT)-1$

0045 DD=0$

0046 CC=AA/2$

0047 BB=CC$

0048 FOR B = 0,1,6$ "NESTED FOR"

0049 BEGIN

0050 IF ARG($A$) EQ ADD($BB$)$

0051 BEGIN "BEGIN TRUE EXIT"

0052 FOUND($A$)=ADD($BB$)$

0053 TEST A$

0054 END "END TRUE EXIT"

0055 IF ARG($A$) GR ADD($BB$)$

0056 BEGIN "BEGIN TRUE EXIT"

0057 CC=BB$

0058 A02. BB= (AA— CC)/2 +CC$

0059 DD=CC$

0060 TEST B$ "TO FOR END FOR B"

0061 END "END TRUE EXIT"

0062 AA=BB$

0063 CC=DD$

0064 TOTO A02$

0065 END @@B@@ "END RANGE CONTROLLED BY B"

0066 END @@A@@ "END RANGE CONTROLLED BY A"

0067 FOR A=0,1,NENT(SEARCH)-1$

0068 BEGIN

0069 IF ARG($A$) NQ FOUND ($A$)$

0070 GOTO ANO$

0071 END

0072 IF TOT NQ 50 $

0073 BEGIN

0074 ANO. CORE(SEARCH,10,5H(ZILCH),1)$ "LIBRARY ROUTINE"

0075 GOTO OUT$

0076 END

0077 CORE(SEARCH,10,6H(A OKAY),1)$ "LIBRARY ROUTINE"

0078 OUT.AA=DD$

0079 STOP$

0080 TERM$

A OKAY

00C3E8 00020002

00C3EC 00000000

00C3F0 000A000A

00C3F4 00090009

00C3F8 00500050

00C3FC 003C003C

00C400 005A005A

00C404 002C002C

00C408 00370037

00C40C 00140014

END OF EXECUTION

END OF JOB