Chasing Seymour, Supercomputing And Punchcards

Book about the CDC-6600 architecture

Back in November last year I wrote about ‘The Supermen‘, the story of Seymour Cray and the birth of supercomputing and mused about my personal reasons to learn about this particular piece of computing history. Reading about something is one thing, getting hands-on experience with technology from the 1960s quite another. Not possible you say?

Online Access to a Supercomputer of the 1960s

The CDC-6500 at the LCM in Seattle

At first I thought so, too. But then I remembered that I read somewhere about the Living Computer Museum + Lab in Seattle’s and its mission to not only exhibit old computers but to have them up and running and accessible to the public, locally and over the Internet. So I had a look and indeed, they have a working CDC-6500, a machine of the first family of supercomputers and designed by Seymour Cray, which can be accessed over the Internet. All original manuals required to work with the machine are available in PDF format. There’s a PDF document on how to use the Interactive Terminal Facility (IAF) via ssh, a guide to the NOS operating system, programming manuals for Basic and Fortran and, very importantly, the PDF version to ‘Design of a Computer – The Control Data 6600‘ by Jim Thornton written in 1970.  The combination of this material together with online access to the real machine and not only to a simulation creates a wonderful experience if one is willing to spend some time on the subject.

It’s Basic!

SSH Session to the CDC-6500

The first thing I did once I had access to the system was to write a small Basic program and run it. I have to admit that this felt a bit strange. I always thought of Basic being a programming language for small microcomputers of the 1980s and not for supercomputers. But there I was, typing-in a Basic program on the IAF console and running it. Except for minor details, the procedure is identical to programming Basic on a home computer 15 years later. Each line needs a line number that is used to sort the program and to act as a jump destination. Just typing the line number deletes it and correcting or changing code on a line requires typing out the full instruction again. In other words, the same thing on the multi-million dollar computer and a home computer a decade and a half later. Who would have thought that? Not me.

Let’s Do The ‘Real Thing’ – Fortran

A Fortran program on the CDC-6500

But o.k., so lets do something a bit more professional I thought and started to read the Fortran manual. As the 1960s was the domain of punch cards and batch driven computing, the manual was focusing on this method of interaction which made it a bit difficult to get my first Fortran program running as there are some differences between Fortran on punchcards and interactive programming on the terminal. But after an hour or so of trial and error and searching for demo programs from that area online, I finally managed to get my program to compile and run. Later, I discovered that it would not have been necessary to venture out to the Internet, the solution was nearer than I thought as there were some Fortran examples in the IAF manual further down in the text. I might have spotted them earlier if I had the printed version to browse. But reading the manual sequentially on the tablet didn’t make it obvious. An interesting take away, I have to browse more in the future even in electronic versions of a manual.

Hardware Peculiarities

The operating system on a tape

What made the 6500 line of CDC computers different from other systems was that the main CPU was there for number crunching and not for interaction with the user or peripherals. Most of the operating system and interaction with printers and storage media such as tapes and disks was the domain of 10 peripheral processors that had their own memory. Communication with the main CPU was done through main memory that all peripheral processors and the main CPU could access. Don’t bother the number-crunching CPU with benign interaction tasks, let it run and do its job while the peripherals do the rest. Multitasking in hardware if you like. Due to this significant difference of how the machine is set up compared to computers on our desks today, it was very worthwhile to read J. Thornton’s hardware description of the machine.

Files That Are Not Files

Another interesting thing I have learned is the different meaning of technical terms then and now. The term ‘storage’ at the time was not only used for tapes and disks but also for main memory, i.e. what we call ‘RAM’ today. Also, ‘files’ to store programs and data were not quite like what we would refer to as ‘files’ today. On the CDC 6500, a file was more like an abstraction of punch cards with individual records inside that could be sorted.

Evolution of the Console

Working with the computer on the console is like looking back in time as well. On the one hand, it feels familiar to type-in commands on the console and get a response back. But there is no directory structure, files are not really files and everything is still tailored around physical teletypes that would print out commands and responses on endless paper. The notion of a simple backspace key that can be used to delete characters, color, a searchable command line history or let alone a cursor that can be moved up and down is not part of the NOS experience, as these things were not possible with a teletype and only became possible with ‘glass-ttys‘ that abstracted and extended the teletypes.

In summary, I am very grateful for the Living Computer Museum to keep these machines alive and accessible to the public from any place in the world. It’s one thing to read about the beginning of supercomputing and mainframes but quite another to actually interact with one and experience the past directly rather than just by reading about it. I especially want to thank Bruce Sherry of the LCM+L for the time he took to answer all my questions and, of course, for keeping this and other machines alive together with his colleagues!