No documentation for this seems to have been preserved, but it appears to be close in features to Dartmouth's 4th edition (1968) BASIC, which does have a manual on bitsavers. Keywords like GOSUB and ON … GOTO are supported, but variables are still only floating point. INPUT is fully supported.

The code is very similar to the version we ran on DTSS, with the only change being the exponentiation operator being **.

100  REM TPK ALGORITHM IN BASIC
110  REM
120  DEF FNT(X) = SQR(ABS(X)) + 5*X**3
130  REM
140  REM MAIN PROGRAM
150  DIM A(11)
160  LET N=11
170  PRINT "PLEASE ENTER", N, "NUMBERS"
180  FOR I = 1 TO N
190  INPUT A(I)
200  NEXT I
210  PRINT "RESULTS ARE"
220  FOR J = 1 TO N
230  LET K = N - J + 1
240  LET R = FNT(A(K))
250  IF R > 400 THEN 280
260  PRINT R
270  GOTO 290
280  PRINT "TOO LARGE"
290  NEXT J
300  END

Note than line 250 has a ? where you'd expect a >. Although this was keyed in as > it was stored as ? due to the limited number of characters supported by MCP.

Source and a transcript of its execution can be found on Github.

MCP supports Fortran 66, which brings some improvements over Fortran II:

• The three-way-if IF (RESULT-400.0) 2,2,1 can now be expressed as a logical test: IF (RESULT .LE. 400) GOTO 2
• Function names no longer need to end with the letter F.

The Burroughs implementation adds some more conveniences:

• Strings can be represented in quoted form "HELLO" rather than Hollerith form 5HHELLO.
• Generic input/output can be done with PRINT / READ rather than specifying a unit number.
• More than one statement is allowed per line, if separated by ;.

The time-sharing version relaxes the fixed column layout to make it easier to enter programs on a terminal. Comments do need to start with C- in columns 1-2, however.

Full information can be found in the 1971 Fortran Manual on bitsavers.

The program now looks like this. The left hand numbers are the line numbers used for entering programs on CANDE. The middle numbers like 101 are Fortran labels.

1000 C-   TPK ALGORITH IN FORTRAN 66
1100      FTPK(X) = SQRT(ABS(X)) + 5.0*X**3
1200 C-   MAIN PROGRAM
1300      DIMENSION A(11)
1400      N=11
1500      PRINT 100
1600 100  FORMAT("PLEASE ENTER 11 NUMBERS")
1700      READ 101,A
1800 101  FORMAT(F9.4)
1900      PRINT 102
2000 102  FORMAT("RESULTS ARE")
2100      DO 3 J = 1, N
2200      K = N - J + 1
2300      RESULT = FTPK(A(K))
2400      IF (RESULT .LE. 400) GOTO 2
2500 1    PRINT 103
2600 103  FORMAT("TOO LARGE")
2700      GOTO 3
2800 2    PRINT 101,RESULT
2900 3    CONTINUE
3000      STOP
3100      END

Source and a transcript of its execution can be found on Github.

I welcome any questions or comments, and also especially any corrections if I have got something wrong. Please email me at rupert@timereshared.com and I will add it here and update the main text.

The MCP batch facility allows you to compile and run programs, and manage files on disk. Interestingly it uses a different syntax from CANDE.

Batch instructions are indicated by an invalid character in column 1, by convention a ?. Multiple instructions per line are allowed if separated by ;. The end of the batch job is indicated by a END instruction.

Batch jobs can be submitted via punched cards, tapes, keyed into the operator console or (if you are not running time-sharing) via the data terminals.

To compile a program you use COMPILE file WITH compiler where file is a file name for the compiled program and compiler is ALGOL, FORTRAN etc. The source can be an existing file on disk or you can take it from cards supplied after the compile directive.

Putting this together, here is how to submit a simple job using punched cards on the emulator. Create a plain text file that looks like this:

?COMPILE LIFE/DISK WITH ALGOL
?DATA CARD
BEGIN
    FILE OUT PRINTER 4 (2, 15);
    INTEGER J;
    J := 42;
    WRITE(PRINTER, /, J);
END.
?END

The first line is a batch directive to create LIFE/DISK using the Algol compiler. The second line indicates that this file should come from the following cards. Next is the Algol program which terminates with END.. Finally, the batch directive ?END finishes the job.

On retro-b6600, switch to the card reader, load this file and press the REMOTE button. On simh, break into command mode on the main simh window by pressing Control-E then typing attach cd0 /path/to/file and then continue.

MCP will sense that there are cards to read automatically. On the operator console you will see work being done as the program is compiled, executed and the results printed.

5:ALGOL/LIFE= 2 BOJ 1020
PBD0004 OUT LINE:ALGOL/LIFE= 2
0:PRNPBT/DISK/SITE= 3 BOJ 1020
ALGOL/LIFE= 2,PST= 1 EOJ
4:LIFE/DISK= 2 BOJ 1020
PBD/0004001 REMOVED
PBD/0004001/0000000= 18 SEGS--CREATED 10/05/25 AT 10:20:16:35
PBD0005 OUT PRINTER:LIFE/DISK= 2
PRNPBT FOR ALGOL/LIFE, PST= 1, IOT= 1; EOJ AT 10:20
PRNPBT/DISK/SITE= 3,PST= 1 EOJ
LIFE/DISK= 2,PST= 1 EOJ
0:PRNPBT/DISK/SITE= 2 BOJ 1020
PBD/0005001 REMOVED
PBD/0005001/0000000= 3 SEGS--CREATED 10/05/25 AT 10:20:18:14
PRNPBT FOR LIFE/DISK, PST= 1, IOT= 1; EOJ AT 10:20
PRNPBT/DISK/SITE= 2,PST= 1 EOJ

Switch over to the printer window on retro-b6600 or the printer file (units/printer.txt) on simh and you will see the compiler output and finally the program running and printing 42. Below is how it looks, slightly edited to remove whitespace:

 LABEL  000000000LINE   00125278?COMPILE LIFE/DISK WITH ALGOL   ALGOL  /LIFE
 LABEL  000000000LINE   00125278?COMPILE LIFE/DISK WITH ALGOL   ALGOL  /LIFE
    BURROUGHS B-5700 ALGOL COMPILER MARK XIII.0     MONDAY, 10/05/25,  10:20 AM.

                BEGIN                             0000
                    FILE OUT PRINTER 4 (2, 15);   0000
                    INTEGER J;                    0003
                    J := 42;                      0003
                    WRITE(PRINTER, /, J);         0004
                END.                              0011
                                                   2 IS   14 LONG, NEXT SEG    1

PRT(31) = OUTPUT(W) INTRINSIC, SEGMENT NUMBER =    3.
PRT(5) = BLOCK CONTROL INTRINSIC, SEGMENT NUMBER =    4.
PRT(14) = ALGOL WRITE   INTRINSIC, SEGMENT NUMBER =    5.
PRT(15) = ALGOL READ    INTRINSIC, SEGMENT NUMBER =    6.
PRT(16) = ALGOL SELECT  INTRINSIC, SEGMENT NUMBER =    7.
                             1 IS    2 LONG, NEXT SEG    0
                             8 IS   69 LONG, NEXT SEG    0

NUMBER OF ERRORS DETECTED =   0.  COMPILATION TIME =    1 SECONDS.
PRT SIZE =  26; TOTAL SEGMENT SIZE =    85 WORDS;
                 DISK SIZE =   9 SEGS; NO. PGM. SEGS =   8
ESTIMATED CORE STORAGE REQUIRED =   696 WORDS.
ESTIMATED AUXILIARY MEMORY REQUIRED =     0 WORDS.

 LABEL  000000000LINE   00125278?COMPILE LIFE/DISK WITH ALGOL
           ALGOL  /LIFE
 LABEL  000000000PRINTER00125278?COMPILE LIFE/DISK WITH ALGOL
           LIFE   /DISK
42,
 LABEL  000000000PRINTER00125278?COMPILE LIFE/DISK WITH ALGOL
           LIFE   /DISK

The above will do a 'load and go' compile, not storing the executable on the disk permanently. If you wish to do this, change the compile command to be:

COMPILE LIFE/DISK WITH ALGOL FOR LIBRARY

and the binary can then later be run with:

EXECUTE LIFE/DISK

Other batch commands are:

file in the above can use the = wildcard: for example, to remove all files under the time-sharing user guest you could do REMOVE =/GUEST.

The operator console, or SPO, allows the operator to monitor tasks and manipulate the running system. It is half-duplex, so it can either be printing or accepting input. To start giving input, press Esc and type the command, terminated by Enter. To abandon the command, press Esc again. simh precedes input with an I and output with an R when printing to the console.

Commands are two letters, like MX. They take optional parameters which are in most cases given after the command. One special case is when you need to provide a 'mix number' or process id: in this case you give the number before the command.

Let's look at some commands that are useful on emulation.

MX will show what jobs are currently running. For example, if I typed this while the above batch job was running I would see:

MX
 0:CANDE/TSHARER= 1
 4:LIFE/DISK= 2
END MX

If I wanted to kill the job, I would find its mix number - here 2 - and 'deep six' the job with the DS command:

2 DS

-OPRTR DS-ED:LIFE/DISK= 2, S= 2, A= 11
 LIFE/DISK= 2,PST= 1 DS-ED

If I had compiled the file to save on disk, I could run the binary via the CC or ? command which takes batch instructions:

? EXECUTE LIFE/DISK; END

 4:LIFE/DISK/SITE= 2 BOJ 1135
 PBD0009 OUT PRINTER:LIFE/DISK= 2

PD will show a listing of files on disk, allowing the = wildcard. To see a list of files starting with FORTRAN:

PD FORTRAN/=
 FORTRAN/TRANS
 FORTRAN/DISK

The image at the top of this post shows the start of a directory listing of all files on the disk via PD =/=.

Here is a full list of operator commands; many of these are only of use when running on real hardware. m means mix number.

On bitsavers, the Operations Manual section 4, "Control Information" starting on PDF page 63, details the batch language and options. The B5500 Handbook section "Keyboard Input Messages" on PDF page 37 defines the operator console commands (except a few time-sharing related ones like CE).

Richard Cornwell also has a good summary of batch commands.

I welcome any questions or comments, and also especially any corrections if I have got something wrong. Please email me at rupert@timereshared.com and I will add it here and update the main text.

100 BEGIN
110     COMMENT TPK ALGORITHM IN ALGOL 60;
120 
130     REAL PROCEDURE FN(X);
140     VALUE X;
150     REAL X;
160     BEGIN
170         FN := SQRT(ABS(X)) + 5 TIMES X * 3
180     END;
190 
200     COMMENT MAIN PROGRAM;
210     INTEGER N, J;
220     REAL ARRAY A[1:11];
230     FILE OUT DCO 19 (1, 10);
240     FILE IN DCI 19 (1, 10);
250     FORMAT NUM(R11.4);
260     FORMAT PROMPT("PLEASE ENTER 11 NUMBERS");
270     FORMAT RESULTS("RESULTS ARE");
280     WRITE(DCO, PROMPT);
290     N := 11;
300     FOR J := 1 STEP 1 UNTIL N DO
310         READ(DCI, NUM, A[J]);
320     WRITE(DCO, RESULTS);
330     FOR J := N STEP -1 UNTIL 1 DO
340     BEGIN
350         REAL RESULT;
360         FORMAT TOOLARGE("TOO LARGE");
370         RESULT := FN(A[J]);
380         IF RESULT GTR 400.0 THEN
390             WRITE(DCO, TOOLARGE)
400         ELSE
410             WRITE(DCO, NUM, RESULT);
420     END;
430 END.

The line numbers are for entry on CANDE and are not used by the program itself. Keywords like INTEGER are reserved and do not need to be quoted.

On line 170, FN := SQRT(ABS(X)) + 5 TIMES X * 3, note that the multiplication operator is the Algol glyph × but we can't type that so we use the text equivalent TIMES. * here is the exponentiation operator. Similarly on line 380 we use GTR to stand in for >.

I/O is not a part of Algol so each implementation does its own thing. Burroughs did it as follows:

• FILE introduces an I/O channel. The 19 refers to the device, here the data terminal. Other devices are listed on p105 of the manual. The (1,10) refers to the buffer size used. Note that input and output each needs a separate FILE variable. FILE declarations are block-scoped, so here the devices are closed automatically at the program END.
• FORMAT works like in Fortran to define how input should be parsed and output presented. We use it here for real numbers (NUM) and some string constants (eg PROMPT).
• READ and WRITE do the actual I/O, taking the file, format and data as their parameters.

On line 390, I originally had WRITE(DCO, TOOLARGE); ie with a semi-colon on the end. This was correctly raised as a syntax error by the compiler as this is not an end of statement situation as the IF clause extends to the ELSE on the next line. The Dartmouth Algol compiler allowed this.

Apart from this, the rest of the implementation works the same way as standard Algol.

When executing this you need to enter numbers in floating point, eg 1.0 instead of 1.

The code and execution transcript for this can be found on Github.

The manual is rather terse, as it is intended as a reference rather than a tutorial, and also does not list in a single place what extensions have been added. However, the text follows the format of the Revised Report on the Algorithmic Language Algol and when each part of the language is introduced in Backus-Naur form it prefaces each of them with a tag:

• 1 means this is the same as the standard
• 2 means this has differences
• 3 means this is new syntax

So this is not a comprehensive list, but some of the interesting extensions I noted while reading the manual:

• Conditional expressions: K := (IF J = 0 THEN 0 ELSE 1 / J);.
• Fill an array: REAL ARRAY A[1:11]; FILL A WITH 42;
• ZIP to run an external program in the background: ZIP("HELLO ", "RUPERT "); would run the hello world example we did earlier.
• TIME(0) gets the current date.
• WHEN(5) pause for 5s
• Can recover from errors eg divide-by-zero via testing flags
• A CASE statement

See the reference manual from 1969 on bitsavers. The other Algol material noted on the Dartmouth DTSS article may also be useful.

I welcome any questions or comments, and also especially any corrections if I have got something wrong. Please email me at rupert@timereshared.com and I will add it here and update the main text.

By default, files are not visible to other time-sharing users on CANDE. With the UNLOCK command you can make them visible and read-only to others; PUBLIC makes them read/write. LOCK returns files to their default state. You can see the protection on files with LIST FILES.

UNLOCK HELLO
#
LIST FILES
09/26/26 RUPERT         02:27 PM
NAME    TYPE     RECS SEGS   CREATED   ACCESSED  W/R  W/B  S-F LOCKD BY
HELLO   BASIC       4   10  09/23/25 * 09/26/25   10  300    7  UNLOCKD
HELLO   OBJ(B)     13   13  09/23/25 * 09/26/25   30   30    7  UNLOCKD
       2  FILES         23  SEGMENTS      17  RECORDS

Other users can access them by adding a / then the user name, eg RUN HELLO/RUPERT.

It's also possible to apply more granular permissions with a GUARD file. You run the interactive GUARD command to create a list of names and permissions, then apply via LOCK WITH. For example, to grant read only access to a staff group containing FRED and MARY:

GUARD
 RUNNING
        

NEW OR OLD LOCK FILE??NEW
LOCK FILE NAME??STAFF
READ ONLY NAMES??FRED,MARY
READ/WRITE NAMES??
ADD, DELETE, LIST, SAVE, OR QUIT?
?LIST
(R) FRED
(R) MARY
ADD, DELETE, LIST, SAVE, OR QUIT?
?SAVE
LOCK FILE SAVED.
ADD, DELETE, LIST, SAVE, OR QUIT?
?QUIT
THANK YOU.


 END GUARD .0 SEC.

LOCK HELLO WITH STAFF
#

Note that this security model only applies to CANDE. Batch jobs can access any file on the system.

You can run a sequence of commands - like a Unix shell script - using the SCHEDULE facility. First you need to create a DATA file containing the commands. DATA files do not have line numbers and their contents can be entered by starting a line with ?DATA and terminating with ?END.

CREATE HRUN DATA
FILE:HRUN - TYPE:DATA  -- CREATED
?DATA
 OK
LOAD HELLO
LIST
RUN
?END

You then issue the SCHEDULE command, giving the file to send output to as the second parameter. The AFTER time parameter is optional, without it the job should be scheduled as soon as possible.

SCHEDULE HRUN TO HOUT AFTER 1530

You can then use STATUS with the output file name to see its status, or STOP to cancel it.

STATUS HOUT
SCHEDULED

However, in practice I have found that these jobs never get executed - they stay in state SCHEDULED forever. Let me know if you find a way to get this working.

This is a way to make a program send input/output to a different place without changing the source code. Say you have this simple Algol program:

FILE:P42    -10/02/25  6:41 PM.

100  BEGIN
110  FILE OUT TYPEWRITER 19 (1, 10);
120  INTEGER J;
130  J := 42;
140  WRITE(TYPEWRITER, /, J);
150  END.

which if run prints 42 to the user's terminal

RUN
 RUNNING
        
42,

 END P42 .0 SEC.

In the code, the FILE statement defines an output file called TYPEWRITER to attach to unit 19, which is the user's terminal. (We'll go into I/O on Algol in more detail in a later post).

Using the CANDE EQUATE verb you can redirect this to a file or another device. The file must already exist before running. So if you wanted to send output to MYOUT:

CREATE MYOUT
SAVE
LOAD P42
EQUATE TYPEWRITER=MYOUT
RUN
 RUNNING

 END P42 .0 SEC.

LIST MYOUT 

FILE:MYOUT  -10/02/25  6:37 PM.

 42,

 END QUIKLST .0 SEC.

Note that the EQUATE only lasts until the next RUN command, but you can stack up more than one EQUATE before running.

There's a way to send single line messages to other users or the operator via the TO command. For example, if It was logged in as GUEST and wanted to send a message to RUPERT:

TO RUPERT HELLO

and if he was logged in he would see:

 ** FROM GUEST   (03)     HELLO

With the first parameter set to SPO it gets sent to the operator's console.

TO SPO HELP I LOST MY TAPE

and they would see:

R ** FROM GUEST(03) HELP I LOST MY TAPE

It's not possible for an end user to add new verbs to CANDE, nor can they use other compilers beyond those already defined. However, all Burroughs sites would receive the source code for CANDE so it would be possible for the system programmers to add these. For example, Georgia Tech added a CALL command to execute programs like GPSS or APL.

Finally here's a list of all commands on CANDE.

In the table, f is a file name; if not given, it assumes the work file. Note that if you have say a file FOO which you load into work and then change, COMPILE will compile that working file, but COMPILE FOO will compile the old version on disk.

Several commands have synonyms not listed here: for example DO does the same as EXECUTE

On bitsavers, the Time-sharing System User's Guide is the best first reference; note this is from a different version of MCP so some of the commands may differ. The Georgia Tech B5700 Time-sharing System Manual is a more complete reference, giving examples of each command, but note this also contains extensions added by Georgia Tech not available on the base Burroughs system.

Also of interest is The Complete CANDE Primer in the Charles Babbage Institute Burroughs collection. However this is from 1980 so for a much enhanced version of CANDE compared to what we have today.

I welcome any questions or comments, and also especially any corrections if I have got something wrong. Please email me at rupert@timereshared.com and I will add it here and update the main text.

On retro-b5500. halt/load the system, and enable time-sharing by entering CE on the operator console. navigate to the terminal (DCA) window and click connect.

On simh, start the system - time-sharing is already enabled if you used the quick-start - then use telnet to connect to port 5500 on localhost. Then give your user name and password.

B5500 TIME SHARING - 01/00, STATION 02
ENTER USER CODE, PLEASE-RUPERT
AND YOUR PASSWORD
RUPERT@@
09/23/25 12:11 PM.
GOOD AFTERNOON, RUPERT LANE     YOU HAVE STATION 02

#

Once logged in, you can either edit a work file or issue commands, in an interface similar to Dartmouth DTSS.

Input lines should be less than 72 characters long. You can use backspace to correct mistakes and Enter to terminate a line - this is a convenience of the emulator; on the real system you'd use ' to backspace and ← to finish a line.

A line starting with " is treated as a comment, ie just printed on the teletype but not saved or processed.

More than one command can be given on a single line by separating them with ;. Commands can usually be abbreviated, eg LIST can by typed as L.

If you get an error message, typing ? will often provide more details.

If you get stuck, eg a program is in an infinite loop, you can interrupt it back to the command level by pressing break, which is Control-E on simh or Control-B on retro-b6600.

CANDE has the concept of a work file which is a temporary copy of a program on disk. You can make a work file by creating a new file or loading from an existing disk file.

File names in CANDE are 6 characters long and must start with a letter.

To create a new work file, use CREATE name type where name is the file name and type is a programming language: BASIC, ALGOL, FORTRAN, or COBOL. You can also set type to be SEQ (for general line numbered files) or DATA (for un-numbered line files).

CREATE HELLO BASIC
FILE:HELLO - TYPE:BASIC  -- CREATED

To load an existing file, use LOAD

LOAD HELLO
FILE:HELLO - TYPE:BASIC  -- LOADING
4 RECORDS LOADED.

Typing a line starting with a number adds to a program or replaces the line if it already exists. Typing a line number on its own will delete that line. Lines can be entered in any order.

You can use the SEQ command (or just the abbreviation +) to automatically create a line number for each line you enter. Terminate it by pressing Enter on a blank new line.

SEQ
100FOR I = 1 TO 5
200PRINT "HELLO, WORLD"
300NEXT I
400END
500
#

As well as retyping a line, there is also the FIX command which can delete or change part of a line.

FIX's syntax is

    FIX line-number delimiter old delimiter [new]

So for the line

    200 PRINT "HELLO, WORLD"

you can change this to "HELLO, EARTH" with

    FIX 200 /WORLD/EARTH

and delete HELLO with

    FIX 200 /HELLO, /

The delimiter used above was /, but this could be any character. Note that only two delimiters are used, compared to say Unix sed where you'd do s/world/earth/.

Note also that FIX only makes changes the next time the file is used (eg on LIST or RUN) - so any errors in your FIX syntax will be presented then, not immediately.

FIX can also be abbreviated to just *.

COMPILE will compile your work file, printing out any errors if found. EXECUTE will run the compiled file. Typing RUN will compile and execute, skipping the compile if the program has not changed.

RUN
 WAIT.

 COMPILING.


 END COMPILE .0 SEC.

 RUNNING
        

HELLO, EARTH
HELLO, EARTH
HELLO, EARTH
HELLO, EARTH
HELLO, EARTH


 END HELLO .0 SEC.

You can use LIST to list out your program; rather than listing the whole file you can give a single line number or a range as parameters, eg LIST 200-300. PRINT is like LIST but will omit the banner.

PRINT 200-300
200 PRINT "HELLO, EARTH"
300 NEXT I

You can see what files you have in your disk area with FILE or for slightly more detail, LIST FILES.

FILES
 *HELLO  HELLO
#
LIST FILES
09/23/25 RUPERT         12:57 PM
NAME    TYPE     RECS SEGS   CREATED   ACCESSED  W/R  W/B  S-F LOCKD BY
HELLO   BASIC       4   10  09/23/25 * 09/23/25   10  300    7
HELLO   OBJ(B)     13   13  09/23/25 * 09/23/25   30   30    7
       2  FILES         23  SEGMENTS      17  RECORDS


 END LFILES .0 SEC.

You can manipulate files with COPY, RENAME and REMOVE, as well as APPEND and MERGE to combine several files.

Type BYE to end your session. If you have modified your work file, you will get an error; you can either type SAVE to save it or DELETE to discard.

When you log off you will see some statistics

 ON FOR  3 MIN, 45.2 SEC.
 C&E USE .0 SEC.
 EXECUTE .0 SEC.
 IO TIME .0 SEC.
 OFF AT   6:50 PM.
 GOODBYE GUEST
07/14/25

If you enter ? to find out details of an error before you have submitted any commands at all, you get:

?
I AM THE GENIE OF THE DISK--WHAT IS YOUR COMMAND?

If you halt/load the system while still connected to the terminal you will see the following when the system comes back up:

P 
 L 
  o 
   P 
RESTARTING . . PLEASE WAIT

In the next post I will go into more details on some advanced CANDE commands.

On bitsavers, the Time-sharing System User's Guide is the best first reference; note this is from a different version of MCP so some of the commands may vary. The Georgia Tech B5700 Time-sharing System Manual is a more complete reference, giving examples of each command, but note this also contains extensions added by Georgia Tech not available on the base Burroughs system.

Also of interest is The Complete CANDE Primer in the Charles Babbage Institute Burroughs collection. However this is from 1980 so for a much enhanced version of CANDE compared to what we have today.

I welcome any questions or comments, and also especially any corrections if I have got something wrong. Please email me at rupert@timereshared.com and I will add it here and update the main text.