Retrotechtacular: The $175,000 Laser Printer

Laser printers today are cheap and readily available. But in 1976, they were the height of printing technology. The IBM 3800 was the $175,000 printer to have in that year. (Video, embedded below.) But you couldn’t have one on your desktop. Even if you could afford it, the thing is the size of a car, and we don’t even want to guess what it weighs. The printer took tractor-fed continuous form paper and could do 167 pages a minute at about 150 dots per inch (actually 180 x 144). For the record, that was as much as 1.7 miles of paper an hour!

In those days, people who would use this printer traditionally had massive banks of noisy impact printers. We imagine this device saved many data processing person’s hearing. Compared to a modern laser printer, though, it needed a lot of maintenance. For example, the initial models needed a xenon flash lamp replaced every month, although later models could go years on one bulb. Looking at some of the hardware in the video, it was probably made closer to the end of life for these printers which were made through 1999.

Continue reading “Retrotechtacular: The $175,000 Laser Printer”

A Mainframe Computer For The Modern Age

The era of mainframe computers and directly programming machines with switches is long past, but plenty of us look back on that era with a certain nostalgia. Getting that close to the hardware and knowing precisely what’s going on is becoming a little bit of a lost art. That’s why [Phil] took it upon himself to build this homage to the mainframe computer of the 70s, which all but disappeared when PCs and microcontrollers took over the scene decades ago.

The machine, known as PlasMa, is not a recreation of any specific computer but instead looks to recreate the feel of computers of this era in a more manageable size. [Phil] built the entire machine from scratch, and it can be programmed directly using toggle switches to input values into registers and memory. Programs can be run or single-stepped, and breakpoints can be set for debugging. The internal workings of the machine, including the program counter, instruction register, accumulator, and work registers, are visible in binary lights. Front panel switches let you control those same items.

The computer also hosts three different microcodes, each providing a unique instruction set. Two are based on computers from Princeton, Toy-A, and Toy-B, used as teaching tools. The third is a more advanced instruction set that allows using things like emulated peripherals, including storage devices. If you want to build one or just follow along as the machine is constructed, programmed, and used, [Phil] has a series of videos demonstrating its functionality, and he’s made everything open-source for those more curious. It’s a great way to get a grasp on the fundamentals of computing, and the only way we could think of to get even more into the inner workings of a machine like this is to build something like a relay computer.

Continue reading “A Mainframe Computer For The Modern Age”

Striping A Disk Drive The 1970 Way

These days, mass storage for computers is pretty simple. It either uses a rotating disk or else it is solid state. There are a few holdouts using tape, too, but compared to how much there used to be, tape is all but dead. But it wasn’t that long ago that there were many kinds of mass storage. Tapes, disks, drums, punched cards, paper tape, and even stranger things. Perhaps none were quite so strange though as the IBM 2321 Data Cell drive — something IBM internally called MARS.

What is a data cell you might ask? A data cell was a mass storage device from IBM in 1964 that could store about 400 megabytes using magnetic strips that looked something like about a foot of photographic film. The strips resided inside a drum that could rotate. When you needed a record, the drum would rotate the strip you needed to the working part and an automated process would remove the strip in question, wrap it around a read/write head and then put it back when it was done.

Continue reading “Striping A Disk Drive The 1970 Way”

Retrotechtacular: The IBM System/360 Remembered

Before IBM was synonymous with personal computers, they were synonymous with large computers. If you didn’t live it, it was hard to realize just how ubiquitous IBM computers were in most industries. And the flagship of the mainframe world was the IBM System/360. For a whole generation that grew up in the late 1960s and early 1970s, a 360 was probably what you thought of when someone said computer. [Computer History Archive Project] has a loving recollection of the machine with a lot of beautiful footage from places like NASA and IBM itself. You can see the video below.

Not only was the 360 physically imposing, but it had lots of lights, switches, and dials that appealed to the nerdiest of us. The machines were usually loud, too, with a Selectric terminal, card punches and readers, noisy 9-track tape drives, and a line printer or two.

Continue reading “Retrotechtacular: The IBM System/360 Remembered”

A briefcase sized electronic machine with many indicator lamps and switches

Restoring A Vintage IBM I/O Tester

By now, [CuriousMarc] and his team of volunteers are well versed in 1960s hardware restoration. So when a vintage IBM I/O Tester came into their possession, a full machine makeover was all but inevitable.

The I/O Tester dates from around 1965, which roughly coincides with the introduction of IBM’s lauded System/360 computer mainframe. In addition to the computer itself, business customers could order a variety of peripherals with their computing system. These included storage devices, printers, additional operator consoles, and so on. Since these peripherals shared the same I/O design, a portable hardware testing rig was a sensible design choice. One portable low-voltage tester could be paired with any number of IBM peripherals, doing away with the need to have unique debugging panels on every piece of computing hardware.

Fast forward to the present day, and the IBM I/O Tester looks positively antique with its blinkenlight lamp panel and switches. To use the tester, simply connect up one (or both) of its chunky 104-pin connectors to your IBM peripheral of choice, insert the accompanying paper overlay, and voilà. Operators could then observe the status of the many lamps to evaluate the inner digital workings of the connected peripheral. Depending on the connected hardware, the tester could reveal the contents of data registers, printing status, disk and tape transfer status, and probably much more. The purpose of the tester’s ninety indicator lights is completely dependent on the attached peripheral, and the paired paper overlays are essential to comprehend their meaning.

After [Ken Shirriff] deciphered the documentation, it wasn’t long before the tester could be powered up using 24 VAC (normally supplied by the equipment being tested). Several burned out lamps were noted for replacement. The lamp assemblies required minor surgery due to a dubious design choice, and at least one of the toggle switches needed a new guide and a heavy dose of contact cleaner before it came back to life.

For the moment, [CuriousMarc] is using the blinkenlights panel as a surprisingly striking retro clock. With a literal truckload of vintage IBM hardware sitting in his storage, it’ll be exciting to see whether this restored tester will be pulled back into operational service someday. Readers should also check out our coverage of his previous major project, restoring an Apollo Guidance Computer.

Continue reading “Restoring A Vintage IBM I/O Tester”

Building A 3270 Terminal Controller

We like to talk about how most of our computers today would have been mainframes a scant 40 or 50 years ago. Because of that, many people who want to run IBM mainframes such as the IBM 360 or 370 use the Hercules emulator to run the big iron on their PCs. However, mainframe IBM computers used an odd style of terminal and emulating it on a PC isn’t always as satisfying. At least, that’s what [lowobservable] thought, so he decided to get a 3270 terminal working with Hercules.

Back in the bad old days of computing, there were two main styles of terminals. Some companies, for example DEC, essentially used terminals as a “glass teletype.” That is, the screen was an analog of a roll of paper — more or less — and the keyboard immediately sent things to the remote system. However, companies like IBM and HP favored a different approach. Their terminals dealt with screens full of data. The terminal was smart enough to let you fill in forms, edit text on the screen, and then you’d send the entire screen in one gulp. Both systems had pros and cons, but — as you might expect — the screen-oriented terminals were more complex.

Continue reading “Building A 3270 Terminal Controller”

COBOL Isn’t The Issue: A Misinterpreted Crisis

Is history doomed to repeat itself? Or rather, is there really any doubt that it isn’t, considering recent events that made the news? I am of course talking about New Jersey’s call for COBOL programmers to fix their ancient unemployment system, collapsing under the application spikes caused by the COVID-19 lockdown. Soon after, other states joined in, and it becomes painfully apparent that we have learned absolutely nothing from Y2K: we still rely on the same old antiques running our infrastructure, and we still think people want to voluntarily write COBOL.

Or maybe they do? Following the calls for aid, things went strangely intense. IBM announced to offer free COBOL trainings and launched a forum where programmers can plug their skills and availability. The Open Mainframe Project’s COBOL programming course suddenly tops the list of trending GitHub projects, and Google Trends shows a massive peak for COBOL as well. COBOL is seemingly on its way to be one of the hottest languages of 2020, and it feels like it’s only a matter of time until we see some MicroCOBOL running on a Teensy.

However, the unemployment systems in question are unfortunately only a tiny selection of systems relying on decades old software, written in a language that went out of fashion a long time ago, which makes it difficult to find programmers in today’s times. Why is that?

Continue reading “COBOL Isn’t The Issue: A Misinterpreted Crisis”