Reprinting the IBM 650

I’m returning to blessed normal after six months of bad anxiety and bad balance. Part of the return is regaining a broader set of interests and a broader use of learning and skills. Programming skills are returning just in time for a new courseware project. Programming includes a fascination with early computers, including older analog and decimal (not binary) electronic computers.

In 2021 I featured the IBM 650, a purely decimal computer. Time for a reprint.

= = = = = START REPRINT:

Previously I showed the 305 RAMAC, which was IBM’s first equipment. The 305 was a complete setup designed to serve accountants and nobody else.

The 650 came slightly before the 305. First produced in 1954, it was just a processor with no input and output capabilities. It had to be connected up to a tape drive and cardpunch for permanent data storage. Later it could connect with the multiple disk pioneered by the 305.

According to Wikipedia, the 650 became the ‘iconic’ computer in movies, with its flashing lights catching your attention. It was also the dominant IBM machine in colleges, so it was the first machine most young programmers saw.

= = = = =

Reviewing the modes of electrical data storage:

Tape came first, as seen in the picture above. The huge disadvantage of tape is that you can’t access any location in the storage quickly. Tape is suitable for reading in a long series of data in a specific order, and then writing out a long series of data in a specific order. It’s not suitable for holding the numbers or categories used in actual computation or decision-making.

All calculators have some form of register, an immediately accessible store for a few numbers.

Mechanical calculators, like this one used by IBM field engineers, hold the number as the positions of rotors. More complex cash registers or adding machines had many registers, built like odometers.

Every electronic computer has at least one register formed by flipflops. A flipflop is the electronic equivalent of a snap-switch, with a pair of opposed tubes or transistors. When one tube conducts, it holds the other tube in a nonconducting state. An input to one side switches the pair to the opposite condition. There’s no real difference between the tube flipflops in the IBM 650 and the extremely miniaturized transistor flipflops in the latest CPU.

Each flipflop is relatively complex, and requires current to maintain its state. So there’s a practical limit to how many registers you can ‘afford’.

The first solution to this problem was the magnetic core or matrix memory, which was dynamic in the modern sense.

Each ferrite core was intersected by several wires. Any current passing through any of the wires induced some magnetic field in the core, which would last for a short time before fading. The currents and the cores were designed so that a current pulse on BOTH of the XY wires through this core would leave a magnetic charge large enough to last for a longer time. I show this charge as enlarging the toroid. After the field has been induced, a much smaller pulse in the coinciding pair would be enoough to trigger a pulse in the sense wire, shown wandering around through all the cores. The sense wire is essentially the secondary winding of a transformer, with the coinciding XY wires as the primary.

That’s how you’d write and read a binary ONE in this particular spot of the matrix. Writing a ZERO was the same thing with reversed polarity. Here I show the opposite induced field as shrinking the core. The sense wire would give an opposite pulse of voltage when the small read pulses coincided.

Core memory was highly dynamic, so it also needed a complex set of refresh pulses to keep it up.

= = = = =

The 650 wasn’t the first to use a drum for a multiple register, but again it became the most famous. I remember seeing the 650 in a college Fortran class in 1967. The instructor showed us all the parts of the computer, and opened up the attic of the 650 to show the drum.

In essence the drum is just a very short multi-track tape loop. Instead of a long and narrow tape, it’s a short and wide tape wrapped into cylindrical form. Each track holds about 50 numbers, repeating over and over.

Each of the V-shaped troughs around the half-cylinder holds a long horizontal series of read-write heads. I’m showing (abstractly) how each head was activated for part of a revolution to access one track of the ‘tape’. This activation wouldn’t be visible in real life.

The drum itself isn’t visible; it’s rotating inside the half-cylinder of heads. The drum held about the same amount of information as a core matrix, but it was non-dynamic. A track once written would stay there without any use of energy or refreshing, and it could be read or rewritten almost instantly.

The 305 RAMAC switched to multiple disks, and we’re still there 65 years later. Same principle as the drum, with tracks in three dimensions instead of two.

= = = = =

The 650 wasn’t only decimal, it was Roman, with a firm dividing line at 5! In other words it was lustrous in both senses. The lights on the front showed the contents of individual flip-flop registers. The knobs and buttons on the front selected which register you were seeing.

The top section was one 10-digit number, with a sign light on the right. Each column was like an abacus. The upper pair was First Five / Second Five. The lower lights were 0 through 4 added onto the upper pair.

The lower part of the front panel was devoted to functions. The left two columns were the opcode of the currently executing command, and the next four were the address of the current command. The lower right lights indicated what was happening now, as in calculating or reading from drum or reading from the external tape.

Here I’m showing opcode 12 and address 3456.

= = = = =

Listing related links so far:

Computers are always sorters.

Parallel is always faster.

Timelines and rentalizing.
Just before the NSA web

When analog fertilized digital

Time was a whole bunch of money!

IBM had Pascal in 1957!

The 305 RAMAC

McBee cards

Not medieval enough

The transition from Roman to decimal in money.

COBOL was designed for purely decimal computers like 650, and retained pure decimalness in binary implementations.

IBM 650 (this item)

And finally, the Poser models are here on ShareCG.