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