ooh, check it out! The operator console from an IBM Model 705 mainframe!

who needs woodgrain when you can just have wood?

no PCB inside, just a lot of individual components and a huge bundle of wires

I love these toggle switches.
They feel like they're off an electric organ.

and so many buttons, and what do they mean?
"half multiple step"?

It's on ebay, bidding is currently up to 100$ https://www.ebay.com/itm/VINTAGE-IBM-Model-705-Mainframe-Operator-Console-Circa-1960-25-L-x-6-9-16-W-x6-H/274451644932

Here's a picture of the full console this would be part of.

The IBM 705 was developed in 1954, as an update of the 702 with increased memory capacity.
The 702 had 2000-1000 characters of Williams tubes memory, the 705 could have 20,000, 40,000, or 80,000 characters in core memory.

Williams tubes are a neat type of early memory, where you display the RAM as a series of dots on a CRT, then a thin sheet of metal in front of the tube is used to read the dots back off. Here's one from a IBM 701

The way the sheet works is interesting. It's not like you had a bunch of sensors for each individual dot, it's just one sheet.
But the way you read memory is by writing to it... yeah.

so you draw a bunch of dots on the screen, representing which bits are on.
This causes redistribution of the electrons in the phosphor coating of the tube, and a positive charge everywhere dots were drawn

to read a location back out, you write to it, setting it high.
If the dot was already drawn, the charge goes positive->positive, and there's no current induced in the metal plate.
But if that dot wasn't drawn (so it's a zero), it goes negative->positive, creating a current

that small current is amplified and transmitted back out, and now you've read your bit.

You do have to refresh this memory, a lot.
The phosphors naturally fade to black, but there'd be dedicated circuits in the computer that do the refreshing of the tubes while the main CPU was doing other things.
(It's very similar to how DRAM controllers work today)

one interesting thing about how the write is destructive (you write a 1 to read out a 1 or a 0, so if it was a zero, you just flipped it) is that the way you'd then set it back to zero would be to write NEXT to the location.

because of how the bits are stored as bits of positive charge near spots of negative charge (where the dislodged electrons landed), to turn a bit back towards neutral, you just drew near it, causing the newly drawn spot to become positive and the original spot negative/neutral

an easy way to do this (for timing reasons) was to draw to the spot while moving the beam, producing a dash.
So in that picture above of the dots, the dots are 1s, and the dashes are 0s.
It's like a weird morse-code memory bank!

These tubes were developed at the University of Manchester, while building the Manchester Baby computer in 1948.
The Manchester Baby was a testbed to confirm confirm the tubes could be used for the Manchester Mark 1

So while the IBM 702 used Williams tubes, the IBM 705 (which this control panel comes from) switched to core memory.

Core memory is really neat. It uses tiny little donut-shaped magnets to store bits. Each one has three wires going through it: the horizontal drive wire, the vertical drive wire, and a sense wire (there's also sometimes an inhibit wire, but later that was merged with sense)

The way it works is that running a current through a coil will cause the magnetic field to be changed to clockwise or counterclockwise, at a certain current.

By running a vertical line at half that current, and a horizontal line at half that current, only the one coil selected will see the full current, and only it'll be affected.
Depending on the direction of the current, it'll flip to either clockwise or counterclockwise

Because the magnets are little circles, there's no magnetic pole to the magnet, the magnetic flux is almost entirely contained within the magnet. So you can put two of them very close to each other without them affecting each other, allowing denser memory

so, you can make the magnets clockwise or counterclockwise. Great. But how do you read it?
Well, the same way you write it! You just set them to clockwise or counterclockwise.

because similar to how an electrical current going through a coil induces a magnetic field, the changing magnetic field induces a current in a wire: The sense wire.

So by writing to a position, you also get a signal out the sense wire... if the bit flipped.
If that coil was clockwise and you set it to counterclockwise, there'll be a small current in the sense wire.
If it was clockwise and you set it to counterclockwise, no current.

and just like Williams tube memory, the read-out is destructive (half the time).
If it was a 1 and you wrote a 0, or vice versa, you just flipped it, and now you have to flip it back.

an interesting thing about core memory is that while there were attempts to build machinery that could automatically produce it, nearly all core memory ended up being made by hand.
It's surprisingly tricky to automate making this sort of thing.

But you know what seemingly unrelated thing is basically the same, and has been done manually by humans for, oh, 9000+ years?

FUCKING WEAVING!

also I was totally wrong about that time period. that was the oldest old world woven textiles.
There's some woven textiles in Peru dated to 11,000-12,000 years ago.

and there's some suggestion (imprints, but no surviving textiles) that weaving was used at the Dolní Věstonice site in the Czech Republi, and that site is 29,000 years old.
So weaving is Quite Old, to say the least.

But yeah. Core memory was heavily used on computers from the mid-50s to mid-70s.
It didn't really start falling out of use until dynamic RAM got cheap enough to replace it, in 1970.

the fun thing about how core memory works is that you access each bit by a vertical and horizontal location, then you can stack a bunch of these core memory planes to get more depth.
In other words, you need an X, a Y, and a Z... it's a 3D cube of memory!