FOCAL (programming language)

FOCAL is an interactive interpreted programming language based on JOSS and primarily used on Digital Equipment Corporation (DEC) PDP-series machines. The name is an acronym for Formulating On-Line Calculations in Algebraic Language.[1]

DeveloperRichard Merrill, DEC
First appeared1968 (1968)
Influenced by

FOCAL is very similar to JOSS in terms of the commands it supports and the general syntax of the language. It differs in that many of JOSS' advanced features like ranges and user-defined functions were removed to simplify the parser. Some of the keywords were renamed so that they all start with a unique first letter. This allows users to type in programs using single-character statements, further reducing memory needs. This was an important consideration on the PDP-8, which was often limited to a few kilobytes (KB), and FOCAL was popular on DEC machines for this reason.

Like JOSS, and later BASICs, FOCAL on the PDP-8 was a complete environment that included a line editor, the interpreter, and input/output routines. The package as a whole was called FOCAL-8, which also ran on the PDP-5 and PDP-12. When ported to the PDP-11, the resulting FOCAL-11 relied on the underlying operating system, RT-11, to provide file support and editing. The language definition was updated twice, to FOCAL-69 and a very slightly modified FOCAL-71.

FOCAL is historically notable as the language for the original versions of the early video games Hamurabi and Lunar Lander. Both were later ported to BASIC where they became much more famous.[2] FOCAL was not popular outside the PDP platform and largely disappeared during the move to the VAX-11. It had a strong revival in the Soviet Union where PDP-11 clones were used as educational and home computers.



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

JOSS was extremely influential in the computer field. It emerged just as the time-sharing concept was being introduced and there was significant interest in man-machine interaction and computers were seeing more widespread use. Whereas most timeshare operating systems of the era concentrated on user account and file management, leaving the users on their own when it came to programming, JOSS provided these functions and an easily used programming language in a single package. Rand showed the system to a parade of people in the industry.[3]


Ports of JOSS to other platforms began to appear shortly after the PDP-6 version was released.

FOCAL was one example, written by Richard Merrill. It removed features as-needed 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, which reduced the amount of state required in the parser. To read the command on a line, it only had to read a single character and then skip forward to the next blank.

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 terms of 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.


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

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 educational market, especially with the growing library of BASIC programs from the Minnesota Educational Computing Consortium, Ahl found selling the machine with FOCAL was difficult in spite of its advantages.[4] 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."[4]

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, FOCAL and FORTRAN as well. Some PDP-11 based EduSystems were also created.[5]

Ahl then began porting programs from FOCAL to BASIC, notably The Sumer Game which he renamed Hamurabi, a version of Lunar Lander, as well as a number of 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.[6][4]

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

Rebirth in the Soviet Union

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,[7] while a BASIC cartridge was an optional add-on. Later models supplied BASIC by default.[8]


The following description is based on FOCAL-69 as seen in the FOCAL-8 language reference manual.[9]

Direct and indirect modes

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.[10]

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.[10]

Program statements

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, leading zeros will be added so that all line numbers will be a total of five characters including the period, but statements referring to those lines do not need the leading zeros, for instance, GOTO 1.10.[11]

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 instance, DO 5 which will jump to the subroutine written in group 5. The editor also used these during edit-time, for instance, 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.[11]

Every line must start with a command keyword following the line number.[11] 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.[12]



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

01.01 ASK "NAME", NAME

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.[14] Equivalent to BASIC's REM.



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.[15]

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 two values are provided, the first is the initial value and the second is the terminating value.

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.[12]

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

A sample FOR loop:

01.30 FOR RATE=4.0,.5,10;DO 2.0
01.40 QUIT


The GOTO command (abbreviation G) jumps program execution to the specified line number.[15] It is identical to the same-named statement in BASIC. Contrast with GO, an indirect command used from the command line that starts programs, the equivalent of BASIC's RUN.

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.[16]

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 instance:

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.[16]


The QUIT command (abbreviation Q) terminates execution of the program and returns control to the editing environment.[14] Equivilant 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.[14] 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.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.[17] Equivalent to BASIC's LET.

01.30 SET PI=3.14156


The TYPE command (abbreviation T) provides for output of one or more items separated by commas.[18] 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 instance, !!! will output three CR/LFs without the need to separate them with commas.[13]

TYPE [NUMBERS, E1, "TEXT", !, #, :, $ OR %] ...OUTPUT
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.[19] So, for instance:

SET A=67823
TYPE %6.01,A
=  67823.0
= 67823
TYPE %8.03,A
=   67823.000
= 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.[20]

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:[21]



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 instance, the following code sample from FOCAL: A New Conversational Language[22] refers to the same variable as DESTINATION and then DES. Internally, both references refer to a value designated DE:

02.30 IF (DES-14) 2.4,3.1,2.4

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


FOCAL-69 contained only five mathematical operators:[23]

  • ^ 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.[23] 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.[23] For instance, 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.[23]

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

  • 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 as well as later versions
  • FSIN() - Sine of an angle given in radians
  • FSQT() - Square root

Other functions

FOCAL also included a number of special-purpose functions:[25]

  • FDIS took two values and plotted a dot on the screen of graphical terminals
  • FADC read a value from a numbered analog input and returned an integer value

Environment commands

Running programs

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.

Editing commands

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

  • ERASE - zeroes out all variables. this is sometimes found within programs to reset them
  • ERASE <nowiki><line number></nowiki> - deletes the statement at the specified line
  • ERASE <nowiki><group number></nowiki> - deletes all statements in the specified group
  • ERASE ALL - deletes the entire program
  • MODIFY <nowiki><line number></nowiki> - allows the programmer to edit the specified line
  • WRITE <nowiki><line number></nowiki> - display the statement at the specified line
  • WRITE <nowiki><group number></nowiki> - display all statements in the specified group
  • WRITE ALL - display the specified program

File commands

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 the file

Library commands

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:]<nowiki><program name></nowiki> - delete a program
  • LIBRARY LIST [device:][file name] - catalog
  • LIBRARY RUN [device:]<nowiki><program name></nowiki> [line number] - chain the program, optionally resuming at the specified line number
  • LIBRARY SAVE [device:]<nowiki><program name></nowiki> - save the program
  • LIBRARY EXIT - return to the PDP-8 monitor program

FOCAL-71 added:

  • LIBRARY CALL [device:]<nowiki><program name></nowiki> - load a program
  • LIBRARY GOSUB [device:]<nowiki><program name></nowiki> [group number] - call a subroutine in an external program

Error codes

Since the interpreter lacked sufficient memory space to store error messages, or even a table of error numbers, FOCAL used a workaround by reporting the address of the error-detecting code as a fixed-point number. For example, the division by zero error was detected it would report ?28.73 @ 01.10, where 28.73 represents the code checking for this error at memory page 28 plus an offset of 73 words, and 01.10 is the line number where the error occurred. Pages in the PDP-8 were 128 bytes long, so this address translates to location 3657.

Changes between versions

DEC released three versions of FOCAL for the PDP-8 series, the original, known simply as FOCAL, and two updated versions, FOCAL,1969 and FOCAL,1971. FOCAL,1969 was largely identical to the original, but FOCAL,1971 was major update that added file handling, new mathematics, and a variety of other changes. In contrast to the first two versions, which were stand-alone systems, FOCAL,1971 was based on the emerging OS/8 (then still known as PS/8) and relied more heavily on that operating system for file handling and editing.


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 it's 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.

Comparison with JOSS

FOCUS is, for all intents, a cleaned-up version of JOSS with changes to make the syntax terser and easier to parse. Almost all FOCAL commands have a one-to-one correspondence with JOSS and differ only in details. A few features of JOSS were missing in FOCAL.

One major difference is that JOSS included a complete set of comparison operations and a boolean logic system that operated within if and for constructs. Furthermore, the ifs and loops could be applied to any statement, in contrast to FOCAL, where the only operation either could carry out was the equivalent to a goto. For instance, in JOSS, one could:

 1.10 Type A if X>10.
 1.20 Type i for i=1(1)10.

Which would optionally print A based on the test, and then print the numbers 1 to 10. In contrast, FOCAL lacked the ability to compare values, and loops were applied by skipping to the next line when they completed. The equivalent code in FOCAL would be:

1.10 IF (X-10) ,,1.30
1.20 TYPE A!
1.30 FOR I=1,1,10;TYPE I,!

JOSS' implementation makes common constructs easier to build and more closely match the programmer's intentions, at the cost of making the runtime more complex. For instance, JOSS allowed ranges in loops to be described in a flexible fashion, for instance, 1,2,3,10(5)50,75,78. This flexibility comes at a cost; in FOCAL the start, stop and step can be written down in a custom in-memory structure and easily updated as the loop is performed. In contrast, the JOSS system requires a pointer to what might be, but often isn't, a more complex expression that has to be stepped over with more complex parsing code.

In terms of making the code terser, changes were relatively minor. For instance, JOSS' Do part 20. becomes the slightly smaller FOCAL DO 20, while Do step 20.1 becomes DO 20.1. Command keywords were also shortened where possible, so JOSS' Demand becomes FOCAL's ASK, both to make it shorter as well as allow the letter D to be uniquely used for DO. The period needed to indicate the end of a line in JOSS was removed.

To simplify the parser, some FOCUS options were removed. For instance, JOSS could perform multiple assignments with Set S=P, P=Q, Q=S. while in FOCUS these had to be made individual statements, SET S=P; SET P=Q; SET Q=S. Likewise, JOSS' Form, used to format output, was combined into FOCAL's TYPE with the %.

Comparison with BASIC

Comparisons between FOCAL and BASIC were inevitable since both languages were common on minicomputers of the same era, and the two languages have much in common in terms of syntax and structure. In most cases, there is a direct conversion of FOCAL code to and from BASIC. For instance, to ask the user to input a value, in FOCUS one would:

 ASK "What is your age?",AGE

while in BASIC the equivalent is:

 INPUT "What is your age",AGE

With the exception of a few features that were missing from one or the other, and some relatively minor differences in syntax, the two languages are very similar.

One notable exception is the IF in BASIC, which allowed any statement to be placed after the THEN, making it more similar with JOSS' control structures. BASIC reversed the ordering of the code compared to JOSS, placing the deciding expression at the start of the line rather than the end, which meant the runtime could immediately abort reading the statement if the expression was not true. FOCAL's IF was more like BASIC's computed goto, ON X GOTO 10,20,30, but the ON...GOTO allowed any number of lines as targets, as opposed to only three for negative, zero and positive as in JOSS and FOCAL.

Another major difference between the two is that FOCAL lacked inherent support for strings as data elements that could be assigned to variables. As was the case in early BASICs or FORTRAN versions before the addition of strings (in F77), this limitation was generally avoided through the use of literal strings in input and output commands. It was only when one had to manipulate individual strings or characters within them that this became a significant problem.

As string variables were not supported, inputting a string used a kludge that converted any characters typed in by the user to their numeric character value. For example, if one typed "HELLO" at an input statement, FOCAL would convert the H to "8", the numeric value of "H" in the PDP-8's six-bit character codes ("H" is the eighth letter). It would then interpret the "E" as starting an exponent, then it would try to compute "8" to the "LLO" power, which would take several seconds of CPU time and result in a value of 0.76593020E+103, not a particularly helpful response. Nevertheless, by asking questions that would be responded to using single-letter responses, programmers could test the result against known character values to produce what looked like character input.

FOCAL's PDP-8 implementation used a floating point representation that represented numbers as four 12-bit words, forty-eight bits in total, with thirty-six bits of mantissa and twelve bits of exponent. This allowed for both significantly higher precision and a significantly wider range of values than most contemporary interpreters and made it a reasonable choice for serious numerical work. This high precision, and good choices for default decimal output formatting, meant that difficulties with binary-to-decimal rounding were not evident to beginning users. For comparison, Microsoft BASIC initially used a 32-bit format, while later versions expanded this to 40-bits. Most BASICs had problems with rounding that led to simple equations resulting in tiny non-zero remainders.

It is generally agreed that FOCAL was more efficient in its use of resources than comparable BASIC systems. On a typical machine of the day, often with 6 to 24 kilobytes of magnetic-core memory, FOCAL could handle larger and more complex programming tasks than BASIC.

Versions and spinoffs

The Coca-Cola Corporation used a customized version of FOCAL called COKE.

FOCAL was later implemented on the PDP-7, PDP-9, PDP-10, PDP-11, PDP-12, PDP-5 and LINC-8.

The FOCAL manual showed how to add commands to the FOCAL parser, so many sites added specialized commands for operating custom hardware.

The Digital Equipment Computer Users' Society collected many patches and enhancements for FOCAL. There were even major enhanced offshoots of FOCAL, such as FOCAL-W, which added many features, including better mass storage file I/O and even virtual variable memory.

In Russia, it saw use as late as the early 1990s in mass-produced home computers of the Electronika BK series.

Example code

The original Lunar Lander makes an excellent example for examining FOCAL code, as it uses most of the features of the language. This code is from the original, found on Jim Storer's Lunar Lander page.[27]

01.50 S A=120;S V=1;S M=32500;S N=16500;S G=.001;S Z=1.8

02.10 T "    ",%3,L,"       ",FITR(A),"  ",%4,5280*(A-FITR(A))
02.20 T %6.02,"       ",3600*V,"    ",%6.01,M-N,"      K=";A K;S T=10
02.70 T %7.02;I (200-K)2.72;I (8-K)3.1,3.1;I (K)2.72,3.1
02.72 T "NOT POSSIBLE";F X=1,51;T "."
02.73 T "K=";A K;G 2.7

03.10 I (M-N-.001)4.1;I (T-.001)2.1;S S=T
03.40 I ((N+S*K)-M)3.5,3.5;S S=(M-N)/K
03.50 D 9;I (I)7.1,7.1;I (V)3.8,3.8;I (J)8.1
03.80 D 6;G 3.1

04.10 T "FUEL OUT AT",L," SECS"!
04.40 S S=(FSQT(V*V+2*A*G)-V)/G;S V=V+G*S;S L=L+S

05.10 T "ON THE MOON AT",L," SECS"!;S W=3600*V
05.40 I (1-W)5.5,5.5:T "PERFECT LANDING !-(LUCKY)"!;G 5.9
05.50 I (10-W)5.6,5.6;T "GOOD LANDING-(COULD BE BETTER)"!;G 5.9
05.60 I (22-W)5.7,5.7;T "CONGRATULATIONS ON A POOR LANDING"!;G 5.9
05.70 I (40-W)5.81,5.81;T "CRAFT DAMAGE. GOOD LUCK"!;G 5.9
05.81 I (60-W)5.82,5.82;T "CRASH LANDING-YOU'VE 5 HRS OXYGEN"!;G 5.9
05.90 T !!!!"TRY AGAIN?"!
05.92 A "(ANS. YES OR NO)"P;I (P-0NO)5.94,5.98
05.94 I (P-0YES)5.92,1.2,5.92 
05.98 T "CONTROL OUT"!!!;Q

06.10 S L=L+S;S T=T-S;S M=M-S*K;S A=I;S V=J

07.10 I (S-.005)5.1;S S=2*A/(V+FSQT(V*V+2*A*(G-Z*K/M)))
07.30 D 9;D 6;G 7.1

08.10 S W=(1-M*G/(Z*K))/2;S S=M*V/(Z*K*(W+FSQT(W*W+V/Z)))+.05;D 9
08.30 I (I)7.1,7.1;D 6;I (-J)3.1,3.1;I (V)3.1,3.1,8.1

09.10 S Q=S*K/M;S J=V+G*S+Z*(-Q-Q^2/2-Q^3/3-Q^4/4-Q^5/5)
09.40 S I=A-G*S*S/2-V*S+Z*S*(Q/2+Q^2/6+Q^3/12+Q^4/20+Q^5/30)

The program is cleanly separated into a number of subroutines. This was almost universal in FOCAL programs (and JOSS), as the line number scheme made such constructs easy to use. This program uses nine routines. The first, group 1, simply prints out the instructions using the Type statement and sets the initial values for the run. The mass of fuel is not recorded directly, instead, it uses the current Mass and empty mass, N, so the remaining fuel is M-N and the lander runs out of fuel when M-N is 0. Also note the Erase at the end of line 1.20, which resets all the variable values.

The main game loop is driven by group 2. As the code "falls" through group 1 into group 2 during the first run, the initial values are printed out in the first two lines. Near the end of line 2.20, the user is Asked to input the burn rate as K, and then the loop timer is reset using S T=10. Line 2.70 tests the user's input against several possibilities, if it is over 200 or below 8 it types "NOT POSSIBLE" and a row of periods, and then loops back to ask the user to try again. If the value is between these values, it jumps forward to group 3. Note that the limited capabilities of FOCAL's IF command are evident here, in BASIC this could be reduced to a single IF K>200 OR K<8 THEN...

Group 3 first tests to see if the fuel has run out, and jumps to group 4 if it has. Then it tests if the 10-second period in T has expired and, if so, loops back to print everything out again, which has the side-effect of resetting T and S to 10. Line 3.40 tests to see if the amount of fuel burned this period, S*K, will reduce the mass of the vehicle as a whole, S*K-M, beyond the empty weight, N. If not, it moves on, if it will, it instead sets the loop timer to the amount of time the remaining fuel will burn, thus ending the loop early. In either case, it calls group 9 to update the velocity and position. It then loops over groups 7, 8 and 9 until the value of I converges.

When the 10-second timer runs out, or it reaches the end due to the fuel test in line 3.10 or the altitude test in 7.10. In the latter cases, it will jump to group 4 and fall through to group 5, or jump to group 5 directly. Group 5 types the end-of-game results and then asks the user if they'd like to try again. If so, it jumps to 1.20 to clear out all values and print the headers again, if not if falls through to 5.98 and Quits.

See also

  • JOSS, the Rand language that inspired FOCAL
  • MUMPS, a data-manipulation language based on JOSS and FOCAL concepts


  1. Manual 1968, p. 1.1.
  2. McCracken, Harry (2014-04-29). "Fifty Years of BASIC, the Programming Language That Made Computers Personal". Time. Archived from the original on 2016-02-05. Retrieved 2016-02-12.
  3. Marks, Shirley (December 1971). The JOSS Years: Reflections on an experiment (PDF) (Technical report). Rand.
  4. Szczepaniak 2014.
  5. EduSystem Handbook (PDF). Digital. 1973. p. V.
  6. Savetz 2013.
  7. Stapleton, R.A.; Goodman, S.E. (June 1988). The Soviet Union and the Personal Computer "Revolution" (PDF) (Technical report). University of Arizona. p. 8.
  8. "Elektronika BK-0010". Old Computer Museum.
  9. Manual 1968.
  10. Manual 1968, p. 2.1.
  11. Manual 1968, p. 2.7.
  12. Manual 1968, p. 3.7.
  13. Manual 1968, p. 3.2.
  14. Manual 1968, p. 3.6.
  15. Manual 1968, p. 3.4.
  16. Manual 1968, p. 3.5.
  17. Manual 1968, p. 3.3.
  18. Manual 1968, p. 3.1.
  19. Manual 1968, p. 2.2.
  20. Manual 1968, p. 2.3.
  21. Manual 1968, p. 2.5.
  22. FOCAL: A New Conversational Language. Digital.
  23. Manual 1968, p. 2.4.
  24. Manual 1968, p. 3.10.
  25. Manual 1968, p. A.3.
  26. Manual 1968, p. 3.8.
  27. "Lunar Lander". Lunar Landing Game Related Documents.


This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.