In 1982, desktop computers were coming into their own, and no clear leaders had emerged. But everyone knew they wanted a piece of the action. This led to, among other things, Sony’s SMC-70, which, frankly, for 1982, was a good-looking, if not oddball, machine. [Tech Tangents] shows the machine off in a recent video.
From the front, the computer looks more-or-less like everything else. But as you move backward, you can see this computer wasn’t another typical entry into the market. One of the things that was the hallmark of successful business computers of the day was expandability. The earlier Altair had the later-titled S100 bus. The IBM PC had the ISA bus. But in both cases, you had to open the box to plug and unplug cards.
Most of us are guilty of romanticizing the past. Do you long to be the captain of a tall ship? Just as long as you don’t mind weevils in your food, vitamin deficiencies, and death from an infection when there were no antibiotics. Want to be a medieval knight? Even worse. But surely, retrocomputing is as fun as we remember, right? Turn your computer on, and it comes up with BASIC! Ready for you to write your own programs. None of this GUI foolishness. Of course, this is just another example of rosy retrospection.
Even if you like BASIC or a similar language today, things have changed. You have a nice text editor, a fast computer, debugging tools, along with things like named functions, no line numbers, and modern control structures. None of those things were very common in the 1980s. At least, not on a hobby-grade computer.
But it quickly got old. Even a simple program gets bogged down with GOTOs and GOSUBs to mysterious line numbers. It made me remember the time back in the early 1980s, or maybe even the late 1970s, that I wrote a BASIC preprocessor to scan BASIC with no line numbers and produce proper source, converting labels to line numbers in two passes.
If you used a serious computer pre-IBM PC, there was a fair chance its operating system was CP/M. CP/M was a staple among 8080 and Z80 computers and while there were other versions, we’ll always associate CP/M with the Z-80. There was a CP/M made for the PC which used an 8088 (a hybrid 8-bit bus with a 16-bit 8086 core), but it was overwhelmed by MSDOS. However, there was another interesting version made for the 68000, and now [johnsonjh] has ported that over to create an early version of CP/M for 80386 protected mode.
The Z-80 only had a 16-bit address bus, so it could only handle 64K of memory. It was common to “bank switch” some memory, and CP/M Plus could be made to understand that (for example, you might have 32K of common memory and three banks of 32K memory; you could address one bank at a time). However, the 386 had a full-blown memory management unit that could remap physical 4K memory pages to anywhere in a program’s virtual address space.
Ordinary CP/M couldn’t handle that, but the Motorola 68000 had a similar page management model, so it makes sense it might be easier to port CP/M-68K to the 80386 than starting from the original, even though the instruction set for the Z-80 is conceptually more similar to the 80386.
What can you do with it? We don’t know. Presumably, it will allow you to use lots of memory. Historically, CP/M software from one variant would not run on another, so you’ll have to build anything you want to use. Of course, the real killer for lots of CP/M memory was multitasking, but that takes MP/M, and only about half of that is currently working. But we won’t be surprised to see it completed soon.
To emulate vintage microprocessor hardware, it’s normal to find a modern host that provides alongside the number-crunching grunt, sufficient physical connections to interface with its support hardware. Thus if you were shopping around it might be reasonable to pick something with a powerful core and plenty of pins. Yet to emulate an 8080, [Ted Fried] has eschewed both of these — opting for an ATtiny85, a microcontroller deficient in both pins and processing power.
This seemingly impossible feat is achieved by reducing the physical connection to an SPI bus and offloading the support functions to a Teensy. The emulation code is significantly optimized C, and includes a 128 byte cache to speed up matters. This delivers a speed claimed to be only very slightly slower than a real 8080 when booting CP/M, which is quite a feat.
We’re sure that CP/M enthusiasts will have fun with this project, and we especially like the full write-up. Going to the effort of making fake 1975 electronics magazine covers for the project really is going the extra mile, and we appreciate that. Meanwhile if you’d like one of your own, the whole thing can be found in a GitHub project.
If you are interested in retrocomputers, you might be like us and old enough to remember the old systems and still have some of the books. But what if you aren’t? No one is born knowing how to copy a file with PIP, for example, so [Kraileth] has the answer: A Gentle Introduction to CP/M.
Of course, by modern standards, CP/M isn’t very hard. You had disks and they had a single level of files in them. No subdirectories. We did eventually get user areas, and the post covers that near the end. It was a common mod to treat user 0 as a global user, but by default, no.
How many lines do you need on a CP/M terminal? More is usually better, of course, but the MicroOffice RoadRunner managed with an 8-row, 80-column LCD screen. That may sound anemic, but in 1983, it was high-tech, as was the RoadRunner, and [Tech Time Traveller] tells us about them in a recent video you can see below.
The intro to the video shows some really strange old laptops before it gets to the RoadRunner. The machine used a Z80 work-alike CPU and a form of CP/M with some organizer functions. The machine didn’t have floppies or other disk storage, but did have four cartridge slots that could hold more memory, a spreadsheet, BASIC, or a text editor. The memory cartridges were static RAM with battery backup, so they retained data when you pulled them from the slot. Assuming the battery didn’t die.
Inside a RoadRunner cartridge.
Unfortunately, this particular machine suffered some shipping damage. In addition to the cartridges, it also had a removable battery and modem. At around the eight-minute mark, the case comes off, and inside are — surprise — more internal cartridges.
While MicroOffice isn’t a household name today, it was founded by a former Exxon executive and tapped a CEO and investor from Timex. It was funded by the likes of Olivetti. The computer rolled out in late 1983 and lived until Telxon bought MicroOffice in 1985.
Attempts to run Zork were not fruitful. There really wasn’t enough memory, and file transfer was a bit wonky. If you want a modern Z80 laptop, we know of one with 16 cores. As clunky as the RoadRunner looks, it still beats the old suitcase computers.
Ever heard of a Dutch company called Holborn (literally, born in Holland)? We hadn’t either, but [Bryan Lunduke] showed us these computers from the early 1980s, and we wondered if they might have appeared in some science fiction movies. They definitely look like something from a 1970s movie space station.
The company started out tiny and only lasted a few years. The Holborn 9100 looked like a minicomputer and, honestly, other than the terminal, looks more like an air conditioner or refrigerator. While it was a Z-80 system, it was clearly aimed at business. The processor ran at 3.5 MHz, there was 72K of RAM that could expand to 220 K — a whopping amount for the early ’80s. They also could accept loads of 8-inch floppies. It even had a light pen, which seems exotic today but was actually fairly common back then.
