CADOL II

CADOL II was the programming language of CADO Systems’ multi-user small business computers of the late 1970s and early 1980s. CADO, based in Torrance, California, sold turnkey accounting machines through a network of independent dealers, and CADOL was how those dealers and their programmers wrote the software. The CADOL II machines had 16K to 48K bytes of RAM, a PROM-resident interpreter and floppy disks. CADOL II arrived in 1978 with CADO’s first four-user machines. It kept the original CADOL’s BASIC-style statements, added commands and strengthened existing ones, and packed each user’s program into 256-byte overlays of one-byte intermediate code. The language spent its whole life on CADO hardware. In the mid-1980s, tools appeared that translated it into C so the applications could move to Unix.

History and Origins

CADO and the first CADOL

Datapro’s January 1979 report on CADO says the company was founded in 1973 by former Pertec and CMC staff. Its first product was the System 40, a small Intel 8080A computer built to sit underneath an AT&T Teletype Model 40/2 terminal and printer. CADO’s founder and chairman, George Ryan, told the Charles Babbage Institute in 1993 that the idea was to “ride the back of AT&T”. The Bell System could not sell data processing equipment itself, so a customer’s Bell terminal could become a business computer with a CADO box underneath. The first System 40 was delivered in the spring of 1976. Datapro says April; Ryan remembered June.

Ryan credited the design to two people. Jim Ferguson, previously chief architect at Northrop’s computer operation, designed the system and its language. Bob Thorne turned it into hardware. Ryan described the language as “a sort of a Basic, a modified Basic” that “became the operating system”. Programs were compiled into a compact code of one-byte operations, which a ROM interpreter executed. Ryan remembered the first machine as having 2K of RAM and 2K of ROM; by 1979 Datapro listed the System 40 at a 5K-byte minimum (2K ROM, 3K RAM). With so little memory, Ferguson divided programs into 256-byte overlays that were loaded from the floppy disk as needed. Ryan recalled that programmers found this discipline hard at first, but that it was “actually … easier to debug because you had such a much smaller piece to work with”.

That first language became known as CADOL I. Datapro’s 1979 report expands the name as Computer Aided Document Origination Language and describes it as “an easily learned English text language that combines program logic coding from BASIC with CADO-designed I/O format and control functions.” A former CADOL programmer’s 2012 blog uses a different expansion, “Computerized Accounting Data Organization Language”. The contemporary Datapro reports use the first form.

CADOL II and the /IV systems

In January 1978 CADO added the System 20. It had the same processor as the System 40 but used a Perkin-Elmer terminal and a Texas Instruments printer, and it cost about 20 percent less. About six months later came the machines that introduced CADOL II: the System 20/IV and System 40/IV. They were announced in the spring of 1978, and Ryan recalled unveiling the four-user machine at a dealer convention in Palm Springs that year. The /IV systems used an Intel 8085A with 20K bytes of memory as standard (4K PROM and 16K RAM), expandable to 52K. Four programmable serial ports let four terminals, printers or communications lines run at the same time.

Datapro’s account of the new language is short:

“The Cado System 20 and System 40 are programmed in CADOL I, and the System 20/IV and 40/IV in CADOL II. … Cado upgraded CADOL I to CADOL II by strengthening existing commands and adding new statements.”

Datapro also says the /IV systems “will accept programs written in either CADOL I or CADOL II”, and that “programs written in CADOL I can be run on any of the Cado systems”. In effect CADOL II extended CADOL I for the new hardware, and the installed base’s existing software kept running. By the time of the report CADO had more than 80 agents, was shipping about 150 systems a month, and had installed over 100 each of the 20/IV and 40/IV.

Design Philosophy

CADOL II followed from its hardware. The machines existed to run accounting, order entry and word processing for businesses buying their first computer, on very little memory and slow floppy disks. The language design made several choices to fit:

• Compile once, interpret compactly. Source is compiled into an intermediate language (IL) of one-byte function commands, some followed by parameter bytes. Datapro notes that this “allows for a compact and efficient interpreter, since syntax errors are detected at compile time rather than at run time.”
• Fixed, pre-allocated storage instead of declarations. Each user gets a fixed set of numeric registers, alphanumeric registers and byte buffers. Nothing is allocated dynamically.
• Terminal handling built into the language. Positioning the cursor, defining protected and unprotected fields, and accepting formatted keyboard input are language operations, not library calls.
• Integer arithmetic for money. Arithmetic is fixed-point binary integer only, with no floating point. The decimal point is handled as display and entry formatting.
• Business-oriented disk files. Records are fetched by key through a hashing scheme that stores the key and the data on the same disk track. Ryan described this as Ferguson’s way to make a floppy disk fast enough for business use.

Key Features

The execution model

On the /IV systems, Datapro describes user memory as “divided into four equal (2K-byte) independent partitions that are controlled by a memory address switching technique.” Each partition holds one user’s registers, buffers and pointers. Program overlays are loaded into a 10-page program pool shared by all users and managed by the system. Several users can run the same overlay from the pool at once. A partition with no terminal assigned can run a background task.

Every program, and every overlay, was limited to 256 bytes of IL. According to Stewart, a program library held up to 256 numbered programs (0-255). Control passed between them with LOAD (jump to another program) and GOSUB/RETURN (call and come back). Accounts of later CADO systems describe a “negative GOSUB”, such as GOSUB -65, which called into a system library supplied by CADO instead of the current one.

Registers and buffers

CADOL II has no named variables in the modern sense. Stewart’s recollection, and a 1983 CADO manual that uses the same names, describe a fixed set of storage areas for each user:

Stewart writes that CADOL III later added N26-N50, alpha registers D and E, and buffers U and V. The Datapro report adds that arithmetic is done on an eight-byte stack, so intermediate results can exceed the six-byte register width without overflowing. It also says an alphanumeric value ends by setting a “Field End” bit on its last character instead of using a terminator byte, and an empty alpha variable is stored as a single Null byte.

Syntax

No CADOL II manual is known to be online, so the syntax below comes from two later sources and should be read as representative, not definitive. Stewart remembered this pattern, which he used to recover cleanly when a user pressed Cancel:

Prog 119:
N19 = 0
LOAD 120 ! Edit

Prog 120:
IF N19 # 0 LOAD 119
N19 = 1

In this example # is the not-equal operator. Pressing Cancel restarted the current program from its first byte, and pressing Escape loaded program 0 of the library. Program 120 therefore used register N19 to notice that it had been restarted and to send control back to program 119, which redrew the screen.

The Prog lines are Stewart’s labels for the two programs, not code. The rest is quoted as he gave it, except that he wrote the second label as “Prog :120”.

CADO’s September 1983 WordBase Data User’s Manual (the product is called JUST ASK III inside the manual) shows how a CADOL program called the report writer. Its Appendix C builds a request in the Y buffer and then calls what it describes as a user-callable subroutine, “commonly called a ’negative GOSUB’”. The manual’s “make an inquiry” sequence is below; the third line is its placeholder, not literal code:

LET Y(1) = 1
LET Y(A) = the name of the form.
GOSUB -65

For the report-producing call, the manual says the subroutine returns with N25 = 0 on success and N25 # 0 on any error. The manual does not say which CADOL version it targets. A deleted Wikipedia article, “CADO Systems Technical Information”, described the later Tiger-era language and survives on mirror sites. It gives record reads such as READ KEY 1 100, followed by SKIP RA(4) and SKIP RN(12) to step over fields in the R buffer and N4 = R(2) to move two bytes into a register. It also says a statement like N5 = 1 compiled to two IL bytes, and IF N5 = 15 RESET to five.

Tooling

Datapro lists the development tools that came with the /IV systems: a source editor, source management programs, the compiler, library management, disk utilities and a debug monitor. Programs were written and compiled on the same machine that ran them. The deleted Wikipedia technical article says programmers often learned the IL itself, and that fixes were sometimes shipped as patches to compiled IL using a patching utility supplied with the operating system.

Evolution

• CADOL I (1976) ran on the single-user System 40 and later the System 20.
• CADOL II (1978) came with the four-user /IV systems. It stayed the language of CADO’s 8-bit machines, including the one-to-eight-station CADO 20/20 family introduced in May 1980, for which Datapro’s 1981 report again names CADOL II. Datapro’s March 1982 small-business survey still lists CADOL II for CADO’s 8085A-based C.A.T. and 20/2x models.
• CADOL III (1983) came with the Tiger ATS series. The ATS 32 and ATS 64 were built from several 8086 and 8089 processors (the later ATS 16 used a single 80186), running the MM/IOS operating system. Datapro’s 1984 report says the top model was designed for 64 workstations, but the configurations then supported stopped at 56. Mini-Micro Systems called CADOL III “the latest version of Cado’s BASIC-like language”. Stewart writes that it lifted the 256-byte limit by allowing up to 32 chained 256-byte segments per program. The Wikipedia account says a careful CADOL III program under 256 bytes of IL could still be compiled to CADOL II code.

Wikipedia’s CADO article also credits Richard Sexton with adding Pascal- and C-like syntax and making overlay loading transparent up to an apparent 65K program, and Dan Lanham with rewriting the compiler. That article is tagged as original research and does not say which CADOL version these changes went into, so they are reported here only as its account.

By early 1983 CADO was a subsidiary of Continental Telecom (Contel). Ryan recalled stepping down at the end of 1982. The CADOL code base outlived the hardware. In April 1986 Computerworld reported Softran Corp.’s C-Tran, “a C software translation program that accepts CADOL II source-code input and generates C source code”, at $4,000 per CPU. It came with a $1,500 C-Run library for the database and terminal functions. Stewart describes a similar later product from Higher Tech that compiled CADOL to C on SCO Unix and was later sold to Link Data in San Diego, where he extended the language further.

Current Relevance

CADOL II is a historical language. There is no public compiler, interpreter or emulator for it, and no known online copy of its reference manual. Surviving documentation is scattered: Datapro reports, CADO brochures and one applications manual on bitsavers and the Internet Archive, and a few programmers’ recollections. The installed base was large and long-lived. Job advertisements asked for CADOL and CADOS experience in 1990 and for CADOL III on Tiger ATS-32 and ATS-64 systems as late as December 1992. Any CADOL code still in use today most likely runs as translated C.

Why It Matters

CADOL II belongs to a distinct branch of computing history: vertically integrated microcomputers sold as complete business systems through dealers, a few years before the IBM PC. Like other proprietary business languages of that period, it was designed backwards from the machine’s job. It had registers and buffers where a general-purpose language would have variables, terminal field handling where one would have print statements, keyed disk records where one would have files, and an intermediate code small enough to run four users on an 8-bit processor with 16K of RAM. Its 256-byte overlays and one-byte IL show how far a small team pushed early microprocessors to compete with minicomputers such as IBM’s System/32 and System/34. The later CADOL-to-C translators show what happened to most languages of this kind: the applications and business logic outlived the hardware and the language they were written in.