Welcome to the Datatron 205 and 220 Blog

This blog is a companion to T J Sawyer's Web Page that outlines the history of the Burroughs Datatron 205 and Paul Kimpel's incredible 205 and 220 emulators. Please visit those sites and return here to post any comments.

Wednesday, February 18, 2015

Reading Some Cards into the Burroughs 205

Paul Kimpel's 205 Emulator continues to develop, with his latest addition being a card reader.  While the start/stop buttons on the reader look relatively modern (can you say that about 1970 technology?) the reader performs like just like a late 1930's IBM 089 collator.

Here's Paul's reader control panel placed atop the Engineer's panel with the familiar "44" command up for execution.

And, just in case you have forgotten, here is a punch card and keypunch to jog your memory. The arrows are pointing to the zone punches in the 12-row and 11-row.

And here is an end view of the IBM 089 collator that served as a reader.  It rented for $85 a month in the 1960 time frame making it the reader of choice on many computers from the ENIAC forward. 
Paul's reader has a big advantage over the actual IBM 089 in that you can readily see the content of the last card read.

That is the final card required on any ALGOL-58 program.  Without that FINISH$ statement (including the $ at the end) the compiler would just keep reading cards looking for the end of the source program.  At the University of Portland, we always kept an IBM card with the required FINISH$ statement lying on top of the 089 to deal with this issue.  It had a large 'Finish Card" scrawled across it with a felt-tip pen.

Tuesday, February 10, 2015

Open Thread - 2/10/2015

This post is for you!

It's time for a new Open Thread!  Our recent posts have pushed the last one down and off the page.  Please feel free to share a comment, especially if you are a former Datatron

Click on the COMMENTS word just below this line. Feel free to post anything that you would like to correct, clarify or add to the Datatron website.

You will need a Google ID (If you have a G-mail account, you have one) or Blogger ID to post a comment.

Friday, February 6, 2015

Compiling Algol 58 Programs on Paul Kimpel's B205 Emulator

As the post below indicates, I have had a long history with the Burroughs 205.  Once Paul got his version of the emulator running with paper tape input, I wasted no time trying it out.

It's funny how the instruction codes from your first computer stick in your head, probably taking up valuable space that could be used for more productive things.  I didn't need an instruction code sheet to write up a square root routine and print out the results.

I also have a long history with the peculiar dialect of Algol 58 that was available on the B205.  The Algol 58 compiler was just waiting to be tried.  It uses the card reader and line printer of the day, both IBM units.  IBM must have loved it when ElectroData, CRC, Logistics Research or other small computer vendors sold a new computer in the mid-1950s.  It meant another IBM 089, 407 and 523 going out on rent for them!

I had a transcribed magnetic tape listing of the Algol compiler sitting on my laptop computer that I knew worked well enough to generate code for at least a few simple programs (see post below.) 

Could I coax it to run in Paul's emulator before he finished implementing the Cardatron read and write commands?  And what about the magnetic tape units that it needed?  Hmmmm....

There is a a paper tape option in the compiler but I had never tried to make it run.  But I had worked with it enough to know there were only a very few references to tape and cards  -  perhaps if I put in a couple of patches?  I also knew where the various table started in the compiler so I could safely put my patches there.

The compiler only uses two Cardatron Write commands so patching that to use the Flexowriter went quickly.  The one Cardatron Read command could be replaced by a PaperTape Read and we'd be good to go.  I was soon ready to test!

Of course, I had chosen years ago to put my simulated mag-tape into an Excel format with block numbers, a separate column for the sign digit and a few other things not compatible with Paul's standard paper tape format.  Excel has wonderful sort and arithmetic capabilities; a new paper-tape version was ready in a jiffy.

I wasn't sure my system would ever come back and read a second card after the first, so my first program was squeezed onto a single line:
X=40;  Y=50;  X1=X + Y + 3.14; STOP;  FINISH;
I anticipated great success, pressed Start and waited.  Of course, it didn't work.  I found a couple of minor bugs in the emulator which Paul promptly fixed and the next day I had success!

Any old-timers with Algol experience will likely recognize the program code beginning in memory location 71.
I now have the compiler working with multiple lines of input.  It is still a bit Kludgy since the source code has to be input in "Cardatron format," which is more than a bit peculiar to the uninitiated.  And the codes for special characters are also oddball.  I developed a webpage with a workaround for that.


Burroughs 205 Emulation - A Personal Story

When I left the University of Portland in 1967 in my '56 Dodge and headed for graduate school in Minneapolis, I packed all of my essential items: Peter, Paul & Mary albums, Beach Boys albums, a good vacuum tube amplifier and turntable and most of my math books.  And, oh yes, a listing of the Burroughs 205 Algol compiler on 11x13 fan-fold paper.

I suppose it is some measure of change over 48 years that "fan-fold" doesn't even have its own entry on Wikipedia.

I've lost track of the number of different places that listing has been stored - but it has been carefully preserved.  I always intended to write a 205 emulator "when I had the time."  The time must have made itself available in the early 1990s since I wrote my first version in VisualBasic.  I wrote a few machine language programs and got those running on the emulator to prove out the machine.

I patiently did a manual transcription of the Algol listing and gave it a shot.  Between my transcription errors and a few emulation errors, it took quite a while before I had my first program compiled.  I started out with just enough instructions implemented to run my machine language square root program.  I would then try to run the compiler and when it used an additional instruction, I would implement that one next.  You could call it a "minimalist" method of implementation.

I set the project aside for several years.  When we first began to spend full winters in Egypt, in early 2009, I decided to re-implement in a more modern language.  I chose JAVA and over the course of the first winter here I got that version running, albeit still incomplete.

But, I did get a number of basic Algol 58 programs to compile on this version.  Much of the work involved struggling with the Algol syntax and special characters that were used on the old Burroughs to represent parentheses and the like.  (I didn't have an Algol 58 manual with me and there were no clues available on the Internet.)

So the news last December from Paul Kimpel last summer that he was planning to construct a "real" B205 emulator was very exciting.  Seeing the product begin to take form with its realistic looking control panels was fascinating.

Congratulations to Paul for having the patience and perseverance to take on this job for what is likely a small audience.