FOCAL (programming language)

JOSS was released in May 1963 on the one-off JOHNNIAC computer at RAND Corporation. In RAND, use grew rapidly, and the machine, originally built in 1953, quickly ran out of capability. JOHNNIAC was decommissioned in 1966 and JOSS was reimplemented on a newly purchased PDP-6, Digital Equipment Corporation's (DEC) first "big" machine. Use continued to grow and by 1970, the system was being used by 500 to 600 users across the country and had spawned several innovations such as mobile computer terminals that could be wheeled from room to room and plugged in for quick access.[4]

JOSS was highly influential. It emerged just as time-sharing was being introduced. There was significant interest in man-machine interaction and computers were seeing wider use. Whereas most time-sharing operating systems of the era concentrated on user account and file management, leaving the users to do their own programming, JOSS provided file editing and a programming language in one package. RAND showed the system to a parade of people in the industry.[4]

The PDP-6 was DEC's first mainframe, and JOSS took full advantage of its power and memory capacity. DEC programmers were interested in JOSS, but most of their machines had nowhere near the power needed to run it. Written by Richard Merrill, FOCAL removed features from JOSS as required in order to be able to run in the much more limited memory space of the PDP-8 and other 12-bit machines in the DEC lineup. To achieve this, a major change was made to reduce the amount of temporary data, or state, needed to parse the statements. One noticeable effect of this decision was that conditionals could only be used for branches, in contrast to JOSS, where conditionals can be applied to any statement.

The other noticeable change was to rearrange the keywords so each started with a unique letter. This simplified the parser, which needed to read only the first letter of the command on a line of code, and could then skip forward to the next whitespace character. It would then compare that against an internal list of possible keywords, which was one character per entry. In contrast, JOSS had to continue reading until it had read the entire command word and then compared that against a list containing complete words. Not only did this change save memory in the parser, users could also save memory by typing in only that letter, reducing the size of the source code.

PDP-8 punched tapes, including a FOCAL-69 tape dated 7/9/69

The first version of FOCAL was released in 1968 for the PDP-8. An updated version followed the next year, which was later known as FOCAL-69. The system as a whole, regardless of version, was known as FOCAL-8 when it was ported to other machines in the 12-bit series, including the PDP-5 and PDP-12. It was popular as it was highly efficient in memory use, which was often severely limited on these machines to a few kilobytes (KB). The similar FOCAL-11 ran on the PDP-11 under RT-11.

Processor Technology also offered a version of 8k FOCAL, complete with Lunar Lander, for the Intel 8080-based Altair 8800 system. This was provided for the copying charge of the tape, while the source code was provided for free with other purchases.[5]

While FOCAL was becoming popular on DEC machines, BASIC was becoming a more popular alternative on other platforms. By the late 1960s, several companies were making inroads in DEC's minicomputer stronghold, selling similar machines running time-sharing versions of BASIC. Notable among these was the HP 2100 series, running HP Time-Shared BASIC.[6]

David H. Ahl had recently joined DEC's PDP-8 Group, just as the company became interested in selling the machine into educational settings. Due to the popularity of BASIC in the education market, especially with the growing library of BASIC programs from the Minnesota Educational Computing Consortium, Ahl found selling the machine with FOCAL was difficult despite its advantages.[6] As he later noted:

DEC's FOCAL language was equal to BASIC in most aspects and even better in some, but it had one huge drawback: DEC was unwilling to license it to other computer manufacturers. FOCAL was fighting an uphill battle against BASIC, which was available on GE, Honeywell, HP, and other computers.
I think it wound up with a situation like Sony and Betamax. Sony saying, "Betamax is ours and it is a better format than VHS," which it was. But then, JVC saying, "We have VHS and Toshiba. Hey, do you want to use it? Fine, we'll license it to you for next to nothing."[6]

Ahl took it upon himself to produce a BASIC system for the platform, hiring a company he later learned was a single programmer in Brooklyn to produce a version for the 4 kWord PDP-8. DEC began selling packaged versions of the PDP-8 with terminals and the BASIC as the "EduSystem" lineup, with larger systems in the series having expanded versions of BASIC, and in some cases, also FOCAL and FORTRAN. Some PDP-11 based EduSystems were also created.[7]

Ahl then began porting programs from FOCAL to BASIC, notably The Sumer Game (which he renamed Hamurabi), a version of Lunar Lander, and many smaller FOCAL demos. Combining his ports with submissions from outside programmers, he managed to collect enough material to have DEC publish 101 BASIC Computer Games in 1973. The book was an immediate success and ultimately ran through three printings to 1975.[8][6]

By the mid-1970s BASIC was a standard feature of all DEC machines and FOCAL use evaporated.[8]

The PDP-11 had been cloned in the Soviet Union in the 1970s for military purposes. In the 1980s, single-chip variations similar to the LSI-11 were produced that gave rise to a series of PDP-11 compatible home computers. Most notable among several models were the Electronika BK series, released in 1985. These were initially supplied with FOCAL on a ROM cartridge,[9] while a BASIC cartridge was an optional add-on. Later models supplied BASIC by default.[10]

FOCAL followed the JOSS model for interaction via a command line interface. This allowed users to type in commands in "direct mode", which were performed immediately, or to prefix them with a line number, in which case they were added to the program if they were unique, or overrode existing code if the same number had previously been used.[12]

The method of operation is similar to BASIC's "immediate mode" vs. "program mode". It contrasts with JOSS, in which all commands, both program and direct, were saved and loaded as part of the user's workspace. This allowed JOSS to have commands without line numbers, which they used for Form definitions and other tasks. FOCAL lacked this capability, so those instructions that needed to be loaded and saved became options on other program-mode commands like Type.[12]

Every line in a FOCAL program must start with a line number. As with JOSS, line numbers are fixed-point numbers consisting of two two-digit integers separated by a period. In FOCAL-8, valid line numbers range from 1.01 through 31.99. When printed out, using WRITE, the FOCAL equivalent to BASIC's LIST, leading zeros will be added; 1.10 will be printed as 01.10. This makes all lines numbers five digits long when output so that all line numbers align. Statements referring to those lines do not need the leading zeros, for example, GOTO 1.10.[13]

The number on the left of the period is known as the "group number". Groups provide some level of code organization that is lacking in languages like Fortran or BASIC. The primary use of these was to use a group as a subroutine which can be called with DO, for example, DO 5 will jump to the subroutine written in group 5. The editor also used these during edit-time, for example, one could WRITE 2 to produce a listing of the code in group 2, or ERASE 4 to delete all of the lines in group 4.[13]

Every line must start with a command keyword following the line number.[13] There is no concept of a "default command" as is the case in BASIC with its optional LET statement. Multiple statements can be placed on a single line, separated by semicolons. Usually, the behavior is no different than if the statements had been on separate lines, except in the case of FOR loops.[14]

The ASK command (abbreviation A) will take a list of strings and variables, echo the strings and store the user input in variables.[15] Equivalent to BASIC's INPUT.

01.01 ASK "NAME", NAME
01.02 ASK "COORDINATES", X, Y
01.03 ASK "A1",A1,"OMEGA",W,"T0",T0,"DAMPING FACTOR",DAMPINGFACTOR

If the user doesn't enter a number but enters text, the system will convert the initial character to a number with "A"=1, "B"=2, etc.

The COMMENT command (abbreviation C) creates a remark.[16] Equivalent to BASIC's REM. The original manual lists CONTINUE as a synonym of COMMENT, used to mark empty lines, but this has no internal difference.[17]

01.01 COMMENT: THE SUMER GAME, BY RICHARD MERRILL

The DO command (abbreviation D) branches execution to a subroutine. It is the equivalent of BASIC's GOSUB. The subroutine is referenced either by group number or line number. If a line number is provided, that single line is run and then returns to the statement after the DO. If no line number is provided, execution starts at the first line of the block and continues until the end of the block is reached or a RETURN is encountered. RETURN is only required to return early from the group, it is not needed at the end of the group.[18]

01.15 DO 7.24
01.16 DO 8

The FOR command (abbreviation F) implements a for loop. When three arguments are specified, the first is the initial value of the loop variable, the second is the increment, and the third value is the terminating value for the loop. If only two values are provided, the first is the initial value and the second is the terminating value, and the increment is set to 1. This is the pattern from FORTRAN's DO loops, as opposed to BASIC's FOR where the increment is the last value, if present.

In contrast to other parts of the language where multiple statements on a line are independent, the FOR always runs the statements that follow it on the line before the termination has been met, and then continues to the next line. Thus, loops have to be on a single line, or alternately, call a subroutine with DO. There is no equivalent of BASIC's NEXT.[14]

01.01 FOR X=1,10; TYPE X,!
01.02 FOR X=0,10,100; DO 2

A sample FOR loop:

01.10 ASK "HOW MUCH MONEY DO YOU WANT TO BORROW ?",PRINCIPAL
01.20 ASK "FOR HOW MANY YEARS ?",TERM
01.30 FOR RATE=4.0,.5,10;DO 2.0
01.40 QUIT
02.10 SET INTEREST=PRINCIPAL*(RATE/100)*TERM
02.20 TYPE "RATE",RATE,"   ","INTEREST",INTEREST,!

The GOTO command (abbreviation G) jumps program execution to the specified line number.[18] It is identical to the same-named statement in BASIC. In FOCAL, GOTO is also used to begin execution, like BASIC's RUN, but in this use, the documentation refers to it as GO instead of GOTO in spite of the underlying command being the same.

01.05 GOTO 1.01
02.90 TYPE !!,"TRY AGAIN.",!!!!!;GOTO 1.1

The IF command (abbreviation I) provides a conditional branch based on the sign of the expression. After the numeric expression, the IF command can take one to three line numbers. If the expression is less than zero, execution branches to the first line number; if equal to zero, to the second line number; if greater than zero, to the third line number. The language lacked relative operators such as greater than, equal or less than. To branch if X > 5, one must compare X - 5.[19]

02.20 IF (25-25) 2.4,2.3,2.4
03.01 IF (X) 3.1,3.02,3.1

IF could be short-formed by placing a semicolon (or end of line) beyond the first line number. For example:

02.20 IF (X)1.8; TYPE "Q"
02.30 IF (X)1.8,2.50
02.40 TYPE "P"

In this case the test at 2.20 will cause the program to jump to line 1.8 if the test is negative, otherwise it will continue and type "Q" to the console. Line 2.30 will jump to 1.8 or 2.5 if the value is negative or zero, and otherwise continue to type "P" to the console.[19]

The QUIT command (abbreviation Q) terminates execution of the program and returns control to the editing environment.[16] Equivalent to BASIC's STOP or END.

01.10 FOR X=-10,1,10;TYPE X
01.20 QUIT

The RETURN command (abbreviation R) branches execution from a subroutine back to the calling location.[16] The use of RETURN is optional at the last line of a subroutine, a subroutine returns at the last line in the group anyway. The following is a sample subroutine for converting a yes/no prompt into a value.

22.78 COMMENT: 'YES OR NO' SUBROUTINE
22.80 ASK "ANSWER YES OR NO ?  ",AN
22.82 IF (AN-0YES)22.84,22.86
22.84 IF (AN-0NO)22.8,22.88,22.8
22.86 SET X=2;RETURN
22.88 SET X=1;RETURN

The SET command (abbreviation S) assigns the results of an expression to the specified variable.[20] Equivalent to BASIC's LET.

01.30 SET PI=3.14156
01.60 SET INTEREST=PRINCIPAL*(RATE/100)*TERM

The TYPE command (abbreviation T) provides for output of one or more items separated by commas.[21] Equivalent to BASIC's PRINT.

Items can be variables, literal strings surrounded by double-quotes, or a variety of control characters. The control characters include the ! to output a carriage return and line feed, # for the carriage return alone, and : for a tab character. Control characters can be strung together, for example, !!! will output three CR/LFs without the need to separate them with commas.[15]

TYPE [NUMBERS, E1, "TEXT", !, #, :, $ OR %] ...OUTPUT
01.10 TYPE "HI THERE, GOOD LOOKING.  HOW MUCH MONEY DO YOU WANT TO BORROW?",!
01.50 TYPE "INTEREST",INTEREST,!
01.80 TYPE "THE INTEREST FOR",TERM," YEARS",!,"IS",INTEREST, " DOLLARS.",!!
01.90 TYPE "NEW YORK",!,"WASHINGTON",!,"ATLANTA",!,"DALLAS",!
02.10 TYPE "X",X,"   ","X^2",X^2,"   ","SQRT",FSQT(X)
03.20 TYPE ".",#
02.20 TYPE !!!!!

TYPE also included an optional format specifier indicated using the format %x.yz, where x is the number of digits to the left of the decimal, and yz is the number of digits to the right of the period. The default format was %8.4, meaning a maximum of eight digits and four to the right of the period.[22] So, for example:

SET A=67823
TYPE %6.01,A
=  67823.0
TYPE %5,A
= 67823
TYPE %8.03,A
=   67823.000
TYPE %,A
= 6.7823E4

Note the extra leading spaces in some examples, padding out the full defined width. Using % alone caused the output to be printed in "floating point format" using the E.[23]

A special control character was $ which caused a table of all defined variables and their values to be printed. Only the first two letters of the name will be printed, padded with a zero if need be. Arrays elements are printed on separate lines and variables with only one element will be indexed (00). For example:[24]

TYPE $
A0(00)=67823

Variable names may start with any letter except F (F is reserved for functions) and may contain any sequence of letters and numbers. However, only the first two characters are significant. For example, the following code sample from FOCAL: A New Conversational Language[25] refers to the same variable as DESTINATION and then DES. Internally, both references refer to a variable designated DE:

01.80 ASK DESTINATION
02.30 IF (DES-14) 2.4,3.1,2.4

Any variable may be treated as an array, allowing subscripts from -2048 through 2047.

FOCAL-69 contained five mathematical operators:[26]

• ^ for exponents – the exponent is converted to a 12-bit integer
• * for multiplication
• / for division
• + for addition
• - for subtraction

One curiosity of FOCAL was that the operators all had independent precedence, as in the order above. That means that the formula SET T=2-3+1, it would be evaluated in the order 2-(3+1) and thus produce -2. This was very different than most languages, where the + and - had equal precedence and would be evaluated (2-3)+1 to produce 0.[26] This can cause subtle errors when converting FOCAL source code to other systems.

FOCAL was unusual in that mathematical expressions could use (), [], and <> interchangeably in matched pairs to establish precedence.[26] For example, the following is a valid expression:

  01.30 SET A=<10*[5+1]*(1+5)>

All of these are the same level of precedence and read left-to-right when at the same level, so this statement will be evaluated [], then (), then <>, to produce 360.[26]

The language contained the following built-in functions:[27]

• FABS() – Absolute value
• FATN() – Arctangent
• FCOS() – Cosine of argument in radians
• FEXP() – Natural base to the power of the argument
• FITR() – Integer part of the argument
• FLOG() – Naperian log
• FRAN() – Random number
• FSGN() – Sign of the argument; FSGN(0)=1 in FOCAL-69, but FSGN(0)=0 in FOCAL-71 and later versions
• FSIN() – Sine of an angle given in radians
• FSQT() – Square root

FOCAL also included several special-purpose functions:[28]

• FADC reads a value from the PDP-8's analog-to-digital converters, with the channel number as the parameter
• FDIS plots at a given Y location
• FDXS plots at a given X location

FOCAL used GOTO in the editor to start a program. However, a rule-of-thumb was to shorten this to GO. This is the equivalent of RUN in BASIC. GOTO can also be used in the editor to start execution at a specified line.

New lines are entered into a program by simply starting the command with a line number. The editing commands were ERASE (abbreviation E),[26] MODIFY (abbreviation M),[29] and WRITE (abbreviation W):[15]

• ERASE – zero out all variables; this is sometimes used in programs to reset them
• ERASE line number – delete the statement at a specified line
• ERASE group number – delete all statements in a specified group
• ERASE ALL – delete an entire program
• MODIFY line number – allow editing a specified line
• WRITE line number – display the statement at a specified line
• WRITE group number – display all statements in a specified group
• WRITE ALL – display a specified program

The file command was OPEN (abbreviation O):

• OPEN INPUT [device:][file][,ECHO] – prepare to read from the start of a file
• OPEN OUTPUT [device:][file][,ECHO] – prepare to write from the start of a file
• OPEN RESTORE INPUT[,ECHO] – resume input
• OPEN RESTORE OUTPUT[,ECHO] – resume output
• OUTPUT CLOSE – output the buffer and close a file

FOCAL included the ability to manage collections of FOCAL programs as a code library. Programs could call other programs in a chain fashion using LIBRARY CALL, or call a single subroutine in another program using LIBRARY GOSUB. Program names could be six characters long. The LIBRARY command (abbreviation L) had the following sub-commands:

• LIBRARY DELETE [device:]program name – delete a program
• LIBRARY LIST [device:][file name] – catalog
• LIBRARY RUN [device:]program name [line number] – chain a program, optionally resuming at a specified line number
• LIBRARY SAVE [device:]program name – save a program
• LIBRARY EXIT – return to the PDP-8 monitor program

FOCAL-71 added:

• LIBRARY CALL [device:]program name – load a program
• LIBRARY GOSUB [device:]program name [group number] – call a subroutine in an external program

One change in the new version was a 10-digit math package for added precision. The FSGN function now returned zero if the input expression evaluated to zero. Previously this would return one. The FRAN now used a better algorithm that produced more randomly distributed numbers. It also added the new FIN function that took a string and returned its ASCII value (akin to BASIC's ASC) and FOUT which took a number and returned a string with that ASCII character (CHR).

As all of these options used up limited memory, when started, FOCAL,1971 entered a dialog that asked the user what features they wanted to use.

• FOCAL Programming Manual (PDF). Digital Equipment Corporation. 1968.
• Szczepaniak, John (1 May 2014). "A basic history of BASIC on its 50th birthday". Gamasutra.
• Savetz, Kevin (April 2013). "Dave Ahl and Betsy Ahl" (Interview).