A language designed at SEA,
Programming on CAB500,
PAF Programmation Automatique des Formules

translation of a communication to Colloque sur l'Histoire de l'Informatique en France 1988

The idea of a an advanced programming language was thought in the industry almost everywhere around the mid-1950s. At SEA, the first atempts of programming the avaluation of mathematical formulas were made in 1956-1957 on CAB 2022. In fact, they were just first attempts of interpreting formulas, the CAB2022 being not suitable for interactive computations. In fact, initially, it was just question to generate a program corresponding to a given formula. The leading idea about an advanced language was to be closer as possible of the manual writing of formulas that was the work method of scientists and engineers. In particular, varaiables were reprented as a single letter and the multiply sign between variables was ommitted. That was the way of thinking that was applied to the input-output devices of the future CAB00. A typewriter and a paper tape reader/punch were the external devices of the machine. The keyboard of the typewriter [a Friden Flexowriter note of tr.] was designed with the PAF as objective. The first versions of PAF were developed in 1957-1958, sometime before the introduction of CAB500. The keyboard included aside from letters and numbers,  a certain number of mathematical symbols and exponents and indices, what allowed not to limit the number of variables to the 26 alphabet letters. The principle of compilation was based on the use of three stacks, operands, operators and priorities,  a process now usual but not well known then.

So, PAF was designed simultaneously with the CAB500 and the introduction was near simultaneous in 1958. In 1959, the definitive version of he language was released with a few improvements.

The memory allocated to a variable contained either a value or an address. When a variable was the result of a formula, its representation was the address of the program of the formula.

It was so possible to reference a variable either by value or by its container what gave many possibilities of programming. The symbol for addressing a container was to enclose the variable name by parenthesis.

After compiling the formulas, the processing of those formulas and of the values assigned to variables was triggered by a high-level language with one statement per line beginning with a keyword specifying thr instruction type, such as
CALCULER   [compute]
ALLER EN    [go to]
IMPRIMER    [print]
Those commands were usually typed at the keyboard (an alternative was to use paper tape).

To ease the user task, it was sufficient to type the first letters of the keyword. As soon as the program was sure of the non-ambiguity, the machine completed the last letters of the keyword.

Those statements could be either executed immediately or reordered and compiled -or more exactly linked together to build a program-. Statements entered for a subsequent compilation had to be entered with a line number in front of the keyword.

A language peculiarity was (contrarily to most recent languages) not to perform variable initialization. That feature allowed the user to assign values after the computation started. The user was to suspend the execution and to modify parameters or values or to request variables values and subsequently to restart the program. [PAF included an interactive debugger always available].

All instructions could be handled conditionally or unconditionally according the resence of a conditional clause SI (<condition>) where <condition> was
either a logical function such as = < > <= >= #
or a condition VARIANTE testing the setting of a switch on the operator console.

Input and Output Operations

In addition to the classical operation:
LIRE <Variable>  [READ]  and
IMPRIMER <variable> (<format>)
there was an instruction
used for easy debugging. That statement stopped the execution of the program and gave control to the keyboard if a push-button at the console was set appropriedly, if the button was reset the statement was a no-op. In debugging mode, the operator was able to read and/or modify variables or to edit instructions.


PAF was handling several types of subroutines that are today usual.

1- Arithmetic pre-programmed fiunctions: trigonometric or exponential, etc... To call them it was enough to enter the name of the function. Note that the programming of them was eased by the use of symbolic instruction, instructions that follow the pattern of ordinary instructions one bit specifying a branch instead of the address of an operand.

2- the evaluation of a function was caused by the statement CALCULER Y, when Y was specified by a single-formula in a single program line.

3- Subroutines written in PAF language. The call to such a suboutine was made through the statement ENTREE n or ENTREE Y,n (when the result of the subroutine was returned to Y) in both cases n was the address 'line number) of the subroutine.

4- Subroutines written in machine language . Calls use the statement PROGRAMME.

5-Other peculiar subroutines, frequently used, such as RESOUDRE ( a set of equations) [SOLVE] have been built-in in the PAF language.

6-Drawing curbs on the typewriter were also built-in statements in PAF

Among the programming languages known as today, there are similarities with BASIC. General principles are quite similar and we wanted to point the original principles of PAF compared to other programming languages . PAF seems to have been developed before BASIC, in any case, BASIC was then unknown to the developers of PAF.