From the Algol source code of the language:

WIPL - WISCONSIN INTERACTIVE PROBLEM-SOLVING LANGUAGE
    BY  ED HARRIS  AND  BOB JANOSKI
    UNIV. OF WISCONSIN COMPUTING CENTER  (MADISON)
VERSION 1.50 (9/1/70)

So we know its name and source, but this is not much help - there is no documentation preserved and an internet search does not turn up much detail. I did find a UW report about a simulation program written in WIPL for school administration from 1969 at the Internet Archive. This includes an instruction manual for running the simulation, showing how to start WIPL and load the program - looks like this was run on the DCMCP rather than via CANDE. But no information on the language itself.

However, the CUBE tape also contains an online help file for the system which defines its syntax and how to use it. Looking at this, what stands out is its use of decimal line numbers and references to PART, for example in this fragment of a sample program:

3.0 TYPE "ENTER THE DEGREE OF THE POLYNOMIAL"
3.1 ACCEPT DEGREE
4.0 TYPE "ENTER THE COEFFICIENTS"
4.1 DO PART 30 FOR I=1 TO DEGREE+1

This makes me think this must be a JOSS clone.

JOSS - the JOHNNIAC Open Shop System - was an early time-shared language created at the RAND corporation in 1963. This ran on the one-of-a-kind computer JOHNNIAC and offered 20-30 users the ability to write simple programs that looked like this:

1.3 Do part 5 for i=1(1)100.
5.1 Type "Hello, Wikipedia!".
5.2 Type "This is JOSS.".

Many places implemented their own version of JOSS under different names (presumably because RAND held the copyright on the name JOSS) - for example BBN developed TELCOMP, DEC had FOCAL and the University of Pittsburgh had PIL. Each version made changes to the syntax but the core of the language was the same - interactive interpreter, decimal line numbers, simple loops and conditionals. The intended user was a scientist or engineer that wanted to do quick calculations but did not want to have to learn a full programming language.

First off, I assume you have the contents of the 'extras' tape installed: if not see this article.

You will need one additional file from the source CUBE tape. Get the file CUBEB13.BCD from Github and attach it to your emulator tape drive, either from the retro-b5500 tape window or via the simh command

at mt0 -r -f p7b /path/to/CUBEB13.bcd

Then switch to the operator's console, press Escape and type:

? LOAD FROM CUBEB13 ERRORS/CARDS; END

This may take a minute or so while the file is located on the tape.

Finally, you will need to rename some files. On the operator console, enter each of these commands:

? CHANGE WIPL/DISK TO 0WIPL/DISK; END
? CHANGE HELPFIL/CARDS TO WIPLS/HELPFIL; END
? ?CHANGE ERRORS/CARDS TO WIPLS/ERRORS; END

You can now run WIPL from CANDE via the RUN WIPL/DISK command. A quick example of starting WIPL, viewing the first help page and trying some immediate mode calculations before quitting and returning to CANDE:

RUN WIPL/DISK
 RUNNING
        

TYPE HELP IF YOU HAVE QUESTIONS  (WIPL VERSION 1.5)
?HELP
PLEASE WAIT.
      YOU ARE USING WIPL, A B5500 INTERACTIVE LANGUAGE DEVELOPED
      BY THE UNIVERSITY OF WISCONSIN COMPUTING CENTER.  TO OBTAIN
      INFORMATION ON THE USE OF ONE OF THE STATEMENT TYPES, TYPE
      "HELP" FOLLOWED BY THE STATEMENT TYPE, SUCH AS "HELP SET".
      IF YOU WOULD LIKE TO KNOW ABOUT ANY SPECIFIC AREA OF THE
      LANGUAGE, YOU MAY CHOOSE FROM THE FOLLOWING LIST OF TOPICS:
      (TO SELECT TOPIC 2.00 TYPE "HELP 2)

 2.00 GENERAL INFORMATION
 3.00 CALCULATOR MODE
 4.00 STORED PROGRAM MODE
 5.00 SPECIAL STATEMENTS
 6.00 DEBUGGING AIDS
 7.00 SAMPLE PROGRAM
?SET A = 2
?SET B = 40
?SET C = A + B
?TYPE C
 42 
?QUIT


 END WIPL .0 SEC.

You can also use SAVE and LOAD to store programs in the file system.

So with this, we can implement the TPK algorithm in WIPL.

1.000 REM TPK ALGORITHM IN WIPL
1.010 DIM A[11]
1.020 PRINT "PLEASE ENTER 11 NUMBERS"
1.030 DO PART 2 FOR J = 1 TO 11 BY 1
1.040 PRINT "RESULTS ARE"
1.050 DO PART 3 FOR J = 11 TO 1 BY -1
1.999 STOP

2.000 REM GET EACH NUMBER AND STORE IN ARRAY
2.010 ACCEPT A[J]

3.000 REM CALCULATE TPK AND DISPLAY RESULTS
3.010 RESULT = SQRT(ABS(A[J])) + 5 * A[J] ** 3
3.020 IF RESULT GTR 400 PRINT "TOO LARGE" ELSE PRINT RESULT

I think this is fairly easy to understand, but here are a few notes. WIPL (and JOSS) programs are separated into parts (the number before the decimal point), each of which may have several lines (the number after the decimal point). A part is like a subroutine with an implicit return when the next part starts. So here we have part 1 for the entry point. It calls part 2 using a loop to input numbers, and then part 3 with a reversed loop to calculate TPK.

Variables are floating point only. Arrays need to be dimensioned before use, and are 1-indexed.

Source and a transcript of its execution can be found on Github. I have also provided a version of the code in JOSS, so you can see how the syntax has changed for WIPL.

While researching this post I found this message by Paul Kimpel. Burroughs had their own version of JOSS, originally called BOSS and later renamed to INTERP. This is actually installed on disk as part of MCP Mark XIII set up. as INTERP/DISK. However, no documentation or help file is available. I can start it, but get the error message:

-INVALID USER INTERPS SAVFILE, S = 43, A = 37

suggesting there may be a step needed to grant access to the program. The source of INTERP is available on the MCP symbol tapes, however, so this would be an interesting project to understand the code and get this version of JOSS working.

Bitsavers has a collection of original RAND documents about JOSS. There is an ongoing project to restore RAND's PDP-6 version of JOSS-II at 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.

• APL\B5500, an APL interpreter from the University of Washington adapted for time-sharing.
• WIPL, the (University of) Wisconsin Interactive Problem-solving Language - a JOSS clone.
• A LISP interpreter reported to come from Fort Monmouth, New Jersey.
• A 1970s era BASIC interpreter called XBASIC from the University of West Scotland

Read on for a brief look at APL. I will cover WIPL in a future article.

For LISP, I could get this running but it crashed on all input. XBASIC also runs but seems to require a tape to do anything useful. Let me know if you have success with these.

• EULER, an early language developed by Niklaus Wirth.
• PASCAL as implemented at Heriot-Watt University in around 1975.
• SNOBOL3 as implemented at the University of Wisconsin.
• GTL, the Georgia Tech Language, created at the university of the same name. An enhanced version of Algol 60.
• MCALGOL, an enhanced version of Burroughs Enhanced Algol, developed at Westinghouse.
• OMNITAB, a statistics language developed by NIST.

Apart from OMBITAB, which is in Fortran, these are all written in Algol. All were designed to run under batch (although CANDE could be customised to run them, as Georgia Tech did) so I will not look at these further.

As top level directories in the collection:

• R/C (Remote/Card), a remote job editor/submit package from Burroughs Defence.
• A Burroughs B6500 simulator and accompanying early MCP for the B5500
• Fragments of Mark-XIV and Mark-XVI MCP
• KRUNCH and UNKRNCH utilities - compress your Algol card deck by removing whitespace and comments.

The CUBE tape has many Algol source code routines. mostly for mathematical/engineering problems, a computer aided teaching system from GT, ELIZA, a tic-tac-toe game, an Algol to Fortran translator written in GTL and many other small programs. The library index is a good place to start exploring these.

Finally, the archive contains a few more recently developed programs

• A Sudoku solver by Paul Cumberworth
• Burroughs B5500-related utility programs for "Emode"
• Utilities from Paul Kimpel and Richard Cornwell

All of the above is in source form. To get them individually installed on your system you will need to compile them and install associated files as per the techniques described in the batch and data transfer posts.

However, a much easier way has been provided by Richard Cornwell, who has made a virtual tape file containing compiled files for many of the above. This is included in the simh distribution and can also be installed on retro-b5500 by getting extras.bin from here, mounting it on the tape drive as a BCD file and entering the command

? LOAD FROM EXTRAS =/=; END

on the console. The file extra.job at the same location also contains a script for building this tape if you want to find out how each component was constructed.

This implementation was created in Burroughs Extended Algol at the Computer Science Group at the University of Washington by Gary Kildall, Leroy Smith, Sally Swedine and Mary Zosel. Gary Kildall became famous later as the creator of the CP/M operating system. The source code was originally found as a printed listing and transcribed to a source file; this was supplanted later by a digital copy found in the CUBE tapes.

This APL was designed to be as compatible as possible with the original APL for the IBM System/360. As typewriters with the APL glyphs did not exist for the Burroughs, alphanumerical transliterations are used, eg Δ is written as $ and ⍴ as RHO.

If you install the contents of the extras tape as described above, you can then start APL from a CANDE prompt by typing RUN APL/DISK. Below is a sample session where I start APL, use calculator mode to do some work, then quit and return to CANDE.

RUN APL/DISK
 RUNNING
        
      APL/B5500 UW COMPUTER SCIENCE # 3-05-71 
      
 LOGGED IN THURSDAY 11-05-25  06:33 
      
X := 30
Y := 12
X + Y
42
      
)OFF
      END OF RUN

 END APL .0 SEC.

I plan to add a project-tpk run of TPK using APL at a later date.

Created by Joseph Weizenbaum at MIT in 1964-6, ELIZA could be called the world's first AI chatbot. I was especially interested to see a version for the Burroughs B5500 having worked on the reconstruction of the CTSS/MAD original.

This version is written in Georgia Tech Language which was mentioned above. GTL incorporated Lisp features into Algol, and the code looks like it was a port of Cosell's Lisp version rather than Weizenbaum's original. The source code is dated 1970-1 and was written by Charles Fricks and John Covert, presumably at Georgia Tech..

Assuming you have installed the extras tape as per the previous section, you will have three files on your system

• ELIZA/SYMBOL - source code
• ELIZA/SCRIPT - run time script file
• ELIZA/ELIZA - executable

In order to run under time-sharing, you will need to rename the executable as CANDE expects runnable code to have a 0 as its first character. Switch over to the operator console, press Escape and type:

? CHANGE ELIZA/ELIZA TO 0ELIZA/ELIZA; END

ELIZA can now be run under CANDE by typing RUN ELIZA/ELIZA. After it starts up, you can interact with ELIZA by typing single lines of text. Type *QUIT to exit. Here's a sample run, using the conversation in Weizenbaum's 1966 ACM paper:

RUN ELIZA/ELIZA
 RUNNING
        

ONE MOMENT PLEASE...
HELLO. HOW ARE YOU TODAY?
?MEN ARE ALL ALIKE.
HOW?
?THEY ARE ALWAYS BUGGING US ABOUT SOMETHING OR OTHER.
WHAT INCIDENT ARE YOU THINKING OF?
?WELL, MY BOYFRIEND MADE ME COME HERE.
DOES THAT SUGGEST ANYTHING ELSE OF YOURS?
?*QUIT
GOODBYE


 END ELIZA .0 SEC.

It has some interesting features that distinguish itself from the original ELIZA:

1. It saves the recall information to a file for use in subsequent sessions.
2. After a certain amount of CPU time is used it will automatically quit with:

I AM VERY SORRY, BUT YOU HAVE USED UP YOUR TIME.

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.

COBOL - the COmmon Business-Orientated Language - is probably the most successful language originating in the 1950s. Designed by a committee to standardise business processing, it was adopted by several computer manufacturers and powered many systems in the finance, retail and government space. Although not used for much new development today, it is still widely in use: the Wikipedia article mentions that as of 2020 "COBOL ran background processes 95% of the time a credit or debit card was swiped". It has an English-like syntax intended to make it easy to read, and has powerful I/O facilities.

On the other hand - it had a reputation for being verbose and over-complicated, with many keywords and quirks in how it processes code. It is rarely taught or studied in academia, and Jean Sammet, historian and one of the language's designers, said:

little attempt was made to cater to the professional programmer, in fact people whose main interest is programming tend to be very unhappy with COBOL

Personally I have never used COBOL nor know anyone who has. I am intrigued to learn more, but the size of the language makes it rather daunting. But before we continue, there is another question to answer.

TPK is a mathematical algorithm: it does floating point calculations and relies on functions such as sqrt and exponentiation. This is rather outside of COBOL's business-orientated domain:

• COBOL uses integer and fixed precision numbers, with floating point support only standardised in the 1980s.
• Mathematical functions like sqrt were also not a standard part of the language until then.

We also do not have contemporary documentation for COBOL on the B5500; the closest is the B7000/B6000 Series COBOL Reference Manual from 1977. This reserved word table starting on p404 notes comparability with the B5700, saying that SQRT was available but floating point numbers (using the COMP-4 type) were not, which seems to be confirmed by my testing.

So to make this a little more tractable, I will do the following:

• Given the lack of floating point numbers, only allow positive integers of two digits as input, and display output as integers.
• Use a LLM to help set up the initial code as a way to get to grips with the language.

(A note on AI: I do not use AI for writing this blog. I will experiment sometimes with using AI to write code, but will clearly mark when it is used).

Unsurprisingly, the LLM said it could not write COBOL for that specific machine, but would write generic COBOL for that era. It knew that sqrt was supported, though.

The code it produced had some formatting and syntax errors when I tried it on CANDE. By consulting the 1977 manual, and reading existing Burroughs batch COBOL programs from the CUBE tape I was able to get it working - but with no guarantees on the quality of the code.

1000 * TPK PROGRAM IN COBOL FOR BURROUGHS MCP
1100 IDENTIFICATION DIVISION.
1200     PROGRAM-ID. TPK
1300     AUTHOR.     RUPERT LANE AND GEMINI
1400 ENVIRONMENT DIVISION.
1500 CONFIGURATION SECTION.
1600     SOURCE-COMPUTER. B-5500.
1700     OBJECT-COMPUTER. B-5500.
1800 INPUT-OUTPUT SECTION.
1900 FILE-CONTROL.
2000     SELECT PRINT-FILE ASSIGN TO PRINTER.
2100 DATA DIVISION.
2200 FILE SECTION.
2300     FD PRINT-FILE;
2400         DATA RECORDS ARE PRT1.
2500     01 PRT1.
2600          05  PRT2         PIC X(120).
2700 WORKING-STORAGE SECTION.
2800     01 NUMBER-TABLE.
2900         05 INPUT-NUMBER   PIC 99.
3000         05 NUMBER-X       PIC 99 OCCURS 11 TIMES.
3100     01 SUBSCRIPTS.
3200         05 NDX            PIC 99.
3300     01 CALCULATION-FIELDS.
3400         05 CURRENT-NUM    PIC 99.
3500         05 RESULT         PIC 9999999.
3600     01 DISPLAY-FIELDS.
3700         05 DISPLAY-RESULT PIC 999.
3800 PROCEDURE DIVISION.
3900 MAIN SECTION.
4000 000-MAIN-LOGIC.
4100     DISPLAY "PLEASE ENTER 11 NUMBERS"
4200     PERFORM 100-ACCEPT-NUMBERS
4300         VARYING NDX FROM 1 BY 1
4400         UNTIL NDX GREATER THAN 11.
4500     DISPLAY "RESULTS ARE".
4600     PERFORM 200-PROCESS-NUMBERS
4700         VARYING NDX FROM 11 BY -1
4800         UNTIL NDX LESS THAN 1.
4900     STOP RUN.
5000 100-ACCEPT-NUMBERS.
5100     ACCEPT INPUT-NUMBER.
5200     MOVE INPUT-NUMBER TO NUMBER-X(NDX).
5300 200-PROCESS-NUMBERS.
5400     MOVE NUMBER-X(NDX) TO CURRENT-NUM.
5500     COMPUTE RESULT = SQRT(ABS(CURRENT-NUM))
5600         + (5 * (CURRENT-NUM ** 3)).
5700     IF RESULT GREATER THAN 400
5800         DISPLAY "TOO LARGE"
5900     ELSE
6000         MOVE RESULT TO DISPLAY-RESULT
6100         DISPLAY DISPLAY-RESULT
6200     END-IF.
6300 END-OF-JOB.

So this is indeed quite verbose - about double the size of the other implementations of TPK I have done. But even without any knowledge of COBOL it is fairly readable.

As in the Algol and Fortran examples, the line numbers are used for entry to CANDE only and are not used by the program itself.

The code is made up of five main divisions - identification, environment, data and procedure. Each contains one or more sections,

The line format is slightly relaxed compared to batch COBOL, with division and section definitions along with labels having to appear on column 1 but other lines can be free format.

The identification division contains structured comments about the propose and authorship of the code.

The environment division is where machine specific details are supposed to be put, such as computer type and selection of peripheral devices. The file-control part sets up the printer as an output device: although I don't use this explicitly, the compiler refuses to work without something being defined here.

The data division contains file and working-storage sections. The file section defines the output format for the printer and is again unused but required. The working-storage section defines variables - these are all global. Variables can be grouped into structures, so NUMBER-TABLE contains INPUT-NUMBER and NUMBER-X. The former is a single variable, the latter is an array introduced by the OCCURS keyword.

The PIC - or picture - keyword defines the variable type. 9 denotes a single digit 0-9, so INPUT-NUMBER PIC 99 means this variable can accept 00-99. RESULT contains the output of the TPK formula so needs to have a capacity of 7 digits to support TPK(99). DISPLAY-RESULT is only 3 digits as we results greater than 400 will not be printed.

The program code is in the procedure division, with control starting at the top. This prompts the user with DISPLAY and then executes two loops with PERFORM, each of which takes a label as the code to execute.

100-ACCEPT-NUMBERS uses ACCEPT to get numbers (must be two digits) and store them. ACCEPT NUMBER-X(NDX) would seem to be the obvious way to get and store in the array, but this gives a syntax error so I have to use the simple variable INPUT-NUMBER and then MOVE it into the array.

200-PROCESS-NUMBERS. calculates TPK and prints the result. Functions are not really part of COBOL so we use the COMPUTE statement, with SQRT, ABS and the exponentiation operator ** being non-standard Burroughs extensions.

One interesting observation is that the COBOL compiler takes longer to run compared to the other languages - on retro-b5500, which runs close to the original hardware speed, it takes 20s for COBOL to compile and 10s for Algol. (simh runs as fast as possible but the difference is still noticeable). This probably comes from the size and complexity of the language, and may partially explain why interactive COBOL was never a great success on time-sharing systems.

The compiler also seems less polished than the Algol one, with several crashes occurring as I worked on the program. For example, if you delete the END-OF-JOB. statement and compile it seems to start reading uninitialised memory:

**ERROR @??????: SEQUENCE NUMBER TRUNCATION -??-
**ERROR @??????: CARD TRUNCATION ??????

-EOF NO LABEL 1S002 RUPERT , S = 27, A = 164

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

Apart from the B7000/B6000 Series COBOL Reference Manual mentioned above there is also Efficient B6700 COBOL from 1981 at the Charles Babbage Institute collection.

There is surprising little material about learning COBOL on the Internet - possibly because of a lack of interest from hobbyists. the University of Limerick had a COBOL course online once but this is now only available on archive.org

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 the printer has a window where you can view output directly and copy information to the clipboard.

On simh, printer output is to a text file - the quickstart uses units/printer.txt.

CANDE provides direct output to the printer via a couple of verbs. LIST FILES TO PRINTER will print a directory listing. COPY file TO PRINTER will print the contents of file, which could be source code or output captured to a file, such as done by the relocation facilities described in a previous article. Here's what a program listing looks like on retro-b5500:

The B5500 printer window on retro-b5500. Source: Rupert Lane. License: CC0.

Using the card punch allows you to get an exact copy of code or data to a text file, without the pagination and spacing imposed by the line printer. This could then be edited on your host machine and the changed file uploaded via the card reader.

To punch from CANDE, use the COPY TO command:

COPY HELLO TO PUNCH
 WAIT.4 RECORDS COPIED (LAST RECORD COPIED=40)


 END COPY .0 SEC.

To actually get output, the operator needs to take some action, as on a real machine they would have to load blank cards for each job. Switch to the operator console and run the appropriately named job HARD/CANDE via the ? command.

This is what it looks like on simh, with input lines preceded by I and output by R. On retro-b5500 there is no prefix.

I ? EXECUTE HARD/CANDE; END
R 
R  5:HARD/CANDE/SITE= 2 BOJ 1059
R  FILE NAMES?
R #HARD/CANDE= 2: ACCEPT

The job is asking you a question about whether to list file names before processing them by prompting FILE NAMES. The next line #HARD/CANDE= 2: ACCEPT means it is waiting for input. Use the AX command to answer no, preceding the command by the mix number (process ID) for the job - this may vary from run to run, but you can see it from the = 2 on the BOJ line, showing on this run it is 2.

I 2 AX NO
R  WHATS NEXT?
R #HARD/CANDE= 2: ACCEPT

To the question WHATS NEXT answer ALL:

I 2 AX ALL
R  PUD0010 OUT PNCH:HARD/CANDE= 2
R  3HELLO/GUEST REMOVED
R  HELLO COPIED TO PUNCH

Now locate the card punch. On retro-b5500 this will be a browser window where you can copy text from. On the simh quickstart it is in units/card-punch.txt. In either case, it will look something like this:

FILE: HELLO/GUEST        PUNCHED: 10/11/25
 
FOR I = 1 TO 5                                           00000010
PRINT "HELLO, WORLD"                                     00000020
NEXT I                                                   00000030
END                                                      00000040

(The above was edited slightly to trim whitespace.)

Note that the line numbers are now on the right side of each line, which is standard for punched cards.

You could also do COPY HELLO TO TAPE and use HARD/CANDE to create a tape file if you wished.

So now we want to do the inverse of the above, provide a text file from your host system to the card reader which will be read and stored to a disk file on the guest. However, there seems to be no built in facility on MCP to do this. Fortunately, Richard Cornwell has written a program called OBJECT/READER that can do this. This program is included in the simh distribution; on retro-b5500 follow these steps to install it.

• Download https://sky-visions.com/burroughs/reader.card
• Go to the card reader window, select reader.card via the browser file picker and press START.
• The operator console will show the job running and the line printer will show the compiler output.
• Confirm the binary was created by going to the operator window, pressing Escape then typing PD OBJECT/READER.

Now on both systems to use OBJECT/READER, prepare a ASCII file representing a batch job that executes it, giving the parameters COMMON=3 and FILE NEWTAPE to be a disk file name. For example, to create a file called BYE on the CANDE account GUEST you could make a file called goodbye.card on your host machine that looks like:

?EXECUTE OBJECT/READER
?COMMON = 3
?FILE NEWTAPE = BYE/GUEST DISK SERIAL
?DATA CARD
FOR I = 1 TO 5                                                          00000100
PRINT "GOODBYE, WORLD"                                                  00000200
NEXT I                                                                  00000300
END                                                                     00000400
?END

On simh, press Control-E on the console to attach the deck and continue;

sim> attach cr0 units/goodbye.card
%SIM-INFO: CR0: 9 card Deck Loaded from units/goodbye.card
sim> continue

On retro-b5500, load the file into the card reader window and press START.

You will see lines printed on the operator console indicating it is running:

R  5:OBJECT/READER= 2 BOJ 1120
R  CRA IN CARD 1:OBJECT/READER= 2
...

and output on the line printer confirming the file contents.

When finished, if you then do LIST FILES on CANDE you will see the file, but with a type of UNKNOWN as this metadata is not part of the file:

LIST FILES
10/11/25 GUEST          11:22 AM
NAME    TYPE     RECS SEGS   CREATED   ACCESSED  W/R  W/B  S-F LOCKD BY
BYE     UNKNOWN     4 1000  10/11/25 * 10/11/25   10  150   99

To fix this, type CHANGE BYE TYPE TO BASIC. You can then LOAD or RUN the program as normal.

HARD/CANDE is documented in the Time-sharing System User's Guide on bitsavers.

OBJECT/READER has other options eg to copy a disk file to the line printer: see the documentation on Richard Cornwell's site for more details.

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.