Burroughs introduced the TC 500 in the early 1970s. It was designed to
be a terminal computer (TC) for banking applications, but could also be used
off-line as a stand-alone small computer in its own right - called the L2000.
It was classified as a "visible record computer".
The L2000 / TC 500 was built into a desk unit built on a box-steel frame. Inside it had a fixed head-per-track disk drive with a 5 millisecond average access time. Most of the storage capacity was taken up by the operating system (firmware), and an extra part was reserved for the data communications elements of the operating system. It had 40 tracks of usable storage. Each track had 32 words, and each word was 8 bytes long. That meant that the 40 tracks gave you 10 KB of storage. However, 2 KB of this was usually locked out for use by the data communications elements of the operating system, so generally you had 8KB of "user memory" to write your application program in.
It had a mechanical 10 character-per-second paper-tape reader that had to be used for loading anything into storage. This reader was not programmable, and could only be used for loading software into the system. When it arrived from the factory, a system did not necessarily have any operating system pre-loaded, so the system had to be "bootstrapped" - enough basic intelligence had to be loaded into the system to allow it to then load its operating system, application software, etc. All memory was "protected" - it could not be written to. Memory jumpers were connected to the relevant areas of memory to un-protect them so that they could be written to. A short "bootstrap" tape was used to load the basic level of intelligence into the system. A tape containing the operating system ("firmware") was then loaded, as well as any "add-ons", such as data communications or peripheral handlers. The memory jumpers were then removed from all memory other than the "user memory" area, so that the firmware area was write-protected.
Once all of the firmware and add-ons were loaded successfully, the application program could be loaded from paper tape. Because the storage medium was non-volatile (disk), once something was loaded it remained loaded permanently unless it was overwritten by something else. Each new program had to be loaded from paper tape to overwrite the previous program. The inbuilt paper-tape reader only operated at 10 characters per second, so loading a program - or even worse, the firmware - took a long time.
On the outside, the L/TC 500 had a 15-inch carriage like a typewriter, though
this was split into two "plattens" (rollers) - the wider one on the
left and the narrower one on the right. The left-hand side was used for
printing on original documents ("visible records"), and the right-hand
side was generally used for printing an audit trail on a "tally roll"
(like the print-out from a cash register). The two plattens could be
advanced independently of each other. It had an in-built 20
character-per-second golfball printer, with a red/black ribbon.
It had a full alphanumeric mechanical keyboard, a separate numeric
keypad including four "operator control keys" (OCKs) and 16
programmable function keys (PSKs or "P-Keys"). The OCKs and
P-Keys could be programmed to set flags that user applications could then pick
up. The keyboard had a buffer of about 20 characters. Its keyboard
layout was therefore very much like that of a modern PC.
The peripherals that were most cherished by the sales force were external
punched paper tape punches and punched paper tape readers, because these
operated at 20 characters per second! The reader could be used for loading
programs faster. It could also be used for accessing user data from
punched paper tape or from edge-punched cards. The punch could be used for
producing copies of user applications, utilities, data tapes and edge-punched
cards. Most users did not have a tape punch, and therefore had no way of
producing their own backup copies of their programs. And most Burroughs
offices didn't have paper tape punches either, so salespeople made sure that
they maintained very good relations with those few users who did have a paper
The L2000 / TC500 could also be fitted with a stationery feed for
Series L/TC computer programs could be written in several ways:
(provided by Rolf Stein)
- in the Burroughs-proprietary GP300
Assembler programming language (SL3, and later SL5 for machines with larger
memory). Using the first part of an assembler program, the instructions
were typed into an L/TC computer equipped with an external paper-tape punch,
which punched out a first-pass tape. The L/TC was then loaded with the
second part of the assembler program, which then read in the first-pass tape via
an external paper tape reader and punched out the final program tape. As
mentioned previously, external paper tape punches and readers were relatively
rare in the field, so this approach wasn't commonly used.
- in COBOL. In this case the
program was written on programming sheets, which were then sent to a Burroughs
data centre to be punched onto 80-column cards. These were then processed
with a COBOL/GP300 compiler application, that produced the final program on
punched paper tape - if the program compiled! If it didn't (which was
usually the case first-time round), the programming sheets had to be changed,
and the whole process had to be gone through again. This could take
several times, and several weeks. As a result, this approach was rarely
- manually. Typically the program would be written onto programming sheets in the GP300 assembler programming language. The programmer would then use a book of conversion tables to convert each GP300 instruction into a "macro" instruction of 4 alphanumeric characters, and write these codes alongside the GP300 instruction on the programming sheet. The programmer would then load the L/TC with a "memory modify" utility, that allowed direct access to any part of unprotected memory of the system. By typing in the relevant memory address, and then typing in the appropriate macro code that was to be written to that address, the programmer could type the application program directly into memory. A standard L2000 had 512 memory addresses, each of which could hold four macro-code instructions. The largest program could therefore require the accurate input of over 2000 instructions. The final program was then punched out on an external paper-tape punch. This was the most common approach used in the field for writing and modifying user applications.
Harvey Schoenman said: "The TC700 (series) was basically a TC500 with passbook handling capabilities. I believe it also had a wider platen. Some models (TC737, TC757) took passbooks with magnetic stripes, and, just like magnetic stripe ledger cards, they held the balance and passbook position information".
The L3000 was identical to the L2000, except that its printer platten was split at a different width and the printer carriage could open and close to allow the operator to insert ledger cards to be printed on.
The L4000 had a 26-inch wide printer carriage (rather than 15-inch) and 24 P-Keys (rather than 16)
The L5000 was based on the L4000, but had a unique new feature - an inbuilt magnetic-stripe ledger card handler.
All Series L/TC models were capable of using plain ledger cards of varying widths, and could roll these cards up and down. However, they were not capable of knowing what was on a ledger card, or of knowing automatically where to position a ledger card to allow the next entry to be posted. This all depended on operator input.
When handling a plain ledger card, the operator would typically type in the account number, the number of the row last used on the card, the balance showing on the card, and a "check digit" (calculated from the previous information using a pre-defined algorithm). The machine would use the row number as a basis for aligning the card correctly for the next posting. Once the posting had been made, the posted amount would be added to the balance, the check digit would be re-calculated, the line entry of the posting would be printed on the ledger card, and the card would then be ejected by the machine.
The magnetic stripe ledger cards used by the L5000 changed this process. A magnetic strip (like a length of tape from a music cassette) was bound into the card itself, near the edge on both the front and back. A magnetic stripe could hold 256 characters of data, such as the account number, name, address, balance, last row used, etc. Rather than having to type all of this information into the machine each time that a posting had to be made to a card, the operator merely had to drop the magnetic stripe ledger card into the L5000's inbuilt handler. The machine drew down the card, read all of the data from the magnetic stripe, and re-positioned the card to the next row number indicated on the magnetic stripe. The operator entered the data to be posted, the machine updated all relevant information, printed out the posting information on the card, and updated the magnetic stripe as it ejected the card.
This speeded up data processing considerably. In addition, it provided a a capability to produce reports that had not existed with previous L/TC machines. By feeding in magnetic stripe ledger cards one after another, a list or report of information held on all cards could be produced automatically (under program control).
Initially, magnetic stripe ledger cards had to be fed into the machine by hand. However, Burroughs then introduced a "feeder/stacker" that could automatically feed batches of cards into the machine and stack them once they had been ejected by the machine.
All processing was highly mechanical, when compared to the more modern use of disk storage.
With the L6000 range of computers, Burroughs replaced the mechanical keyboard and inbuilt paper tape reader with an electronic keyboard and paper tape reader. As a result the keyboard was much quieter, and applications loaded faster because the paper tape reader operated at 20 characters per second. The system still used a gold-ball printer, though it printed at a faster 30 characters per second (as compared to the earlier models' 20 characters per second).
The L6000 was a family of computers, aimed at replacing earlier models. The L6200 replaced the L2000; the L6300 replaced the L3000; the L6400 replaced the L4000; and the L6500 replaced the L5000.
However, the earlier models of the Series L/TC still remained operation in customer sites for many years.
Is this a mystery machine? It seems like a number of people in Burroughs in the USA worked on them, but I've not been able to find out much detail about them as yet.
Harvey Schoenman said: "its internal operations (firmware instructions) were unique and were counter to the other Ls, which were all basically extensions on the previous model. Also, none of the other techs would touch the L7 and there was a customer that was buying a pair of them and needed a number of custom programs created. It was quite lucrative for me. I never found it difficult to program for. Especially in COBOL with the compiler on a Med Sys (B2500-B4900 and V-series) with a paper tape punch".
Roger Peters said: "I believe there was also a very short lived L7000 system if I remember right. I believe it tried to leverage the old disk memory concept while painfully trying to do things better suited for the B700. I heard of one that tried doing a relatively small memory sort that ran overnight and it didn't stay installed long."
Dave Cox (Burroughs Machines 1969-1974) sent in this description of the L7000 and how it fitted in with the B700 and B1700 models.
"The L7000 was released in late 1970, I think, and was an extension of the earlier L series. The virtual machine / firmware was SL/7, and had a few useful extensions to the earlier SL/3 (L2000 etc) machine: in particular, it was much better at handling 80-column punched card. However Burroughs made what we in the UK thought was a very bad decision, in refusing to release the assembler for it, forcing people to program it in COBOL (which, as you know, required the help of a medium systems mainframe, B3500 or similar). The assembler existed, my boss even brought back a bootleg copy of it from Plymouth, Michigan, but they wouldn't support it. So we didn't, couldn't, use it. That didn't help.
"Around that time, Burroughs were panicking badly over the huge success of the IBM System/3, and three US plants were tasked with coming up with a competitor for it.
"The first of these to come out with an offering was Plymouth, and this was a souped-up L7000 called the MS5000 (I think, not sure now). It was an L7000 with, additionally, two external disk drives (removable cartridges) in one cabinet, a mag tape drive and a line printer. I was one of the lucky software guys tasked with getting involved with this beast, and went to its introduction to Europe in Feb 1971 in a hotel on the shores of Lake Zurich, Switzerland. All went well there, and an International contingent, me included again, went to Plymouth in August 1971 for our initial training (due to last a month). It quickly became obvious this machine was a complete and utter dud. I have never seen anything run so slowly. We, in teams, wrote COBOL programs to read and validate sales orders from 80-column card, compiled them and ran them. My program (and I wasn't a complete idiot) read two cards a minute. The MS5000 was abandoned midway through the course and never heard of again. I don't think the L7000 itself lasted very much longer.
"The second offering was from Downingtown, Pennsylvania, and became the B700. It too ran the SL/7 virtual machine, but on utterly different hardware (originally a military thing called the 'D machine'), though it had the same peripherals as the MS5000. It too was programmed in COBOL and needed a medium system to compile on (though they later came up with an RPG compiler that ran, very slowly, on the B700 itself). I spent a happy year in Detroit, 1971/72, with an international team, writing some of the first COBOL applications for this beast and helping to specify the 'utilities' (like Memory Modify that you mentioned re the L2000) that came out with it. That included a month in Downingtown itself, running these programs for the first time on the first prototypes - and that was quite an experience. A machine that needed its microcode reloading about every ten minutes was a bit of a trial. Of course, the engineers sorted it out eventually. It was moderately successful in its day.
"And the third, from Goleta, California, was the extraordinary B1700, which also
became quite successful. A similar team was working on it at the same time as
we were doing the B700. "
This range of computers was aimed at replacing all previous models of the Series L/TC family.
The L8000 family of computers was much faster than all previous models, as it used MOS (metal oxide semiconductor) memory, rather than slower core memory. MOS memory was "volatile", and lost all of its contents when the machine was powered down, and so programs had to be reloaded when the machine was powered up again.
The L8200-L8500 models were equipped with a 20 character-per-second golfball printer, like the earlier Series L/TC computers. The L8600-L8900 models also had a golfball printer that ran at 30 character-per-second.
The L8000 was again a family of computers. The L8200 replace the L2000 and L6200; the L8300 replaced the L3000 and L6300; the L8400 replaced the L4000 and L6400; and the L8500 replaced the L5000 and L6500.
Two peripherals were also introduced that would work with this new L/TC family. One was a range of "line printers", which were compatible with Burroughs small minicomputers (the B700 and B1700 family). These could print at speeds of up to 200 lines per minute.
The second peripheral - a tape cassette unit - marked a major technological step for Burroughs. For the first time, an L/TC system could operate without the use of individual records, such as ledger cards. Instead, all of the data could be written to cassette, as a file. All of the records in the file could be processed without manual intervention.
An L8000 could be equipped with up to four cassette drives, each of which could both read and write cassettes. Account data could be held on one cassette drive, an operator could post new data to a second cassette drive, and resulting data could then be written to a third cassette drive to produce a new updated account data file. Cassettes could only be read and written sequentially - there was no random access, but the cassette drive could do a high-speed sequential search.
For the first time, a Series L machine could also sort data automatically. Data was loaded from the source cassette into memory, and two other cassette drives were used as temporary storage. The resulting sorted data was then written out to another cassette drive.
Cassette drives could also be used to store user applications, which also allowed them to be loaded faster.
The last of the Series L/TC family to be produced was the L9000 range. The main difference between these systems and the L8000 range was the speed of the inbuilt matrix printers, with the first models printing at 60 characters per second and the last models produced printing at up to 150 characters per second. The memory of the system was also faster.
The L9000 range was the last of the Burroughs visible record computers. It's replacement - the smaller Series B models - no longer used ledger cards - instead it used removable disks.
Send mail to firstname.lastname@example.org
with questions or comments about this web site.
Copyright © 2017
Last modified:01 January 2017