It's not really, you know.
IBM i is very interesting: the last mainstream single-level store system. This is a concept I've both talked and written about in recent years -- examples here on HN:
https://news.ycombinator.com/item?id=26066762 https://news.ycombinator.com/item?id=32314814
Saying that, I've done very very little work on the system. One job ever, really, 20Y ago.
But IBM i is OS/400, yes, a minicomputer OS, yes -- but running on IBM P series, i.e. a POWER server, i.e. a modern RS/6000. It's a RISC workstation. Not even slightly mainframe-like.
Other minicomputer OSes survive, notably VMS, now on x86-64.
https://www.theregister.com/2022/05/10/openvms_92/ <- Another of my stories, just so you know where I stand.
So, yes, mini OSes survive, sure, but not really any mini hardware. Arguably as minicomputers died out they evolved into workstations, and those have now died out, too. 99.99% of the workstation market is basically high-end PCs now, if we count modern Macs as sort of honourary PCs. (Arm Macs are in some ways more like desktop/laptop-shaped iPads, really.)
Source: me, two decades doing IBM sysprog on AS/400s and z/OS.
All I'd say is this: "midrange" is an IBM sales concept, and I don't think it was ever really used much outside IBM.
"Minicomputer" is a generally-accepted industry term, or at least, it was once. Minicomputers were not specific to IBM, just as mainframes weren't either.
- You lose a screwdriver inside: minicomputer
- You lose a technician inside: mainframe
When you bring a new addition to your personal collection:
- your wife complains: microcomputer
- Your wife yells at you: minicomputer
- Your wife leaves you: mainframe
So, mainframes have channel controllers, and micro-computers don't. But a modern micro-computer Ethernet driver might run some software on the NIC. It's not really a channel and yet the architectural distinction is blurred.
The distinctions made more sense in the 80's, when the lines were clearer.
But I think the point is valid: the micro-computer architecture has taken over the industry, and some things of value have been lost.
But the modern PCIe "bus" is really more of a packet-switched network. Memory is now separate (although, see CXL). Devices on that network can talk directly to each other, or to the CPU. In some ways, this is closer to a mainframe architecture.
Separate processors in storage, in terminals, in networking controllers, in printers, in everything. Typically the machine cannot actually drive any output or input directly (e.g. mouse movements, or keystrokes, or anything): peripherals do that, collect and encode the results, and send them over a network. So as someone else commented, a mainframe isn't really a computer, it's a whole cluster of closely-coupled computers, many with dedicated functionality. Quite possibly all implemented with different architectures, instruction sets, programming languages, bit widths, everything.
Here's an article I wrote about a decade back about how IBM added the new facility of "time sharing" -- i.e. multiple users on terminals, all interacting with the host at the same time -- by developing the first hypervisor and running 1 OS per user in VMs, because the IBM OSes of the time simply could not handle concepts like "terminal sessions".
https://www.theregister.com/Print/2011/07/14/brief_history_o...
Minicomputer: the 2nd main style of computer. Smaller, cheaper, so affordable for a company department to own one, while mainframes were and are mostly leased to whole corporations. Typically 1 CPU in early ones, implemented as a whole card cage full of multiple boards: maybe a few boards with registers, one with an adder, etc. The "CPU" is a cabinet with thousands of chips in it.
Hallmarks: large size; inherently multitasking, so that multiple users can share the machine, accessing it via dumb terminals on serial lines. User presses a key, the keystroke is sent over the wire, the host displays it. Little to no networking. One processor, maybe several disk or tape drives, also dumb and controlled by the CPU. No display on the host. No keyboard or other user input on the host. All interaction is via terminals. But because they were multiuser, even the early primitive ones had fairly smart OSes which could handle multiple user accounts and so on.
Gradually acquired networking and so on, but later.
In some classic designs, like some DEC PDPs, adding new hardware actually adds new instructions to the processor's instruction set.
Wildly variable and diverse architectures. Word lengths of 8 bit, 9 bit, 12 bit, 18 bit, 24 bit, 32 bit, 36 bit and others. Manufacturers often had multiple incompatible ranges and maybe several different OSes per model range, depending on the task wanted, so offering dozens of totally different and incompatible OSes across half a dozen models.
Microcomputer: the simplest category. The entire processor is implemented on a single silicon chip, a microprocessor. Early machines very small and simple, driven by 1 terminal with 1 user. No multitasking, no file or other resource sharing, no networking, no communications except typically 1 terminal and maybe a printer. Instead of 1 computer per department, 1 computer per person. Facilities added by standardised expansion cards.
This is the era of standardisation and commoditisation. Due largely to microcomputers, things like the size of bytes, their encoding and so on were fixed. 8 bits to a byte, ASCII coding, etc.
Gradually grew larger: 16-bit, then 32-bit, etc. In the early '80s gained onboard ROM typically with a BASIC interpreter, on-board graphics and later sound. Mid-'80s, went to 16-bit with multicolour graphics (256+ colours), stereo sound. Lots of incompatible designs, but usually 1 OS per company, used for everything. All single-user boxes.
These outperformed most minis and minis died out. Some minis gained a hi-res graphical display and turned into single-user deskside "workstations", keeping their multitasking OS, usually a UNIX by this point. Prices remained at an order of magnitude more than PCs, and processors were proprietary, closely-guarded secrets, and sometimes still implemented across multiple discrete chips. Gradually these got integrated into single chip devices but they usually weren't very performance competitive and got displaced by RISC processors, built to run compiled C quickly.
In the '90s, generalising wildly, networking became common, and 32-bit designs became affordable. Most of the 16-bit machines died out and the industry standardised on MS Windows and classic MacOS. As internet connections became common in the late '90s, multitasking and a GUI were expected along with multimedia support.
Apple bought NeXT, abandoned its proprietary OS and switched to a UNIX.
Microsoft headhunted DEC's team from the cancelled MICA project, merged it with the Portable OS/2 project, and got them to finish OS/2 NT, later Windows NT, on the N-Ten CPU, the Intel i860, a RISC chip, then on MIPS, and later on x86-32 and other CPUs. This was the first credible commercial microcomputer OS that could be both a client and a server, and ultimately killed off all the proprietary dedicated-server OSes, of which the biggest was Novell Netware.
That is a vastly overlong answer but it's late and I'm just braindumping.
Mainframe: big tightly-clustered bunch of smart devices, flying in close formation. Primary role, batch driven computing, non-interactive; interactivity bolted on later.
Mini: departmental shared computer with dumb terminals and dumb peripherals, interactive and multitasking from the start. Most text-only, with interactive command-line interfaces -- "shells" -- and multiprogramming or multitasking OSes. Few had batch capabilities; no graphics, no direct I/O, maybe rare graphical terminals for niche uses. Origins of the systems that inspired CP/M, MS-DOS, VMS, UNIX, and NT.
Micro: single-chip CPU, single-user machines, often with graphics and sound early on. Later gained GUIs, then later than that networking, and evolved to be servers as well.
If the machine can control and be controlled by a screen and keyboard plugged into the CPU, it's a micro. If its CPU family has always been a single chip from the start, it's a micro. If it boots into some kind of firmware OS loader, it's probably a micro. The lines between micros and UNIX workstations are a bit blurred.
I'm not sure this is helping any more. I'll shut up.
This enables the central CPU running the application server to ignore all the terminal I/O issues, and just deal with a set of transactions implementing the application logic. If the load-balancer and HTTP server are separate machines, then at a high-level boxes-and-lines level, it's not a long way from a mainframe application architecture (at the front end, anyway).
But this isn't really accurate, and it's become less superficially similar with more recent web trends where the REST layer isn't a hard boundary, and pre-rendering and so on have muddied the model again.
I think it (as in, late-era Web 1.0 as opposed to Web 2, meaning Javascript everywhere) bears deeper examination.
By which I mean, I think the world and the industry got distracted by the shiny, as it always does, and is so into Javascript and building clever stuff in it, that nobody has taken the time to stop and ask: hey, was Javascript a bad idea?
Which leads on to...
Could we experimentally stop using it and be better off? Could we go back a step, improve upon Web 1, without embedded scripting languages of any kind, and maybe produce a better web based on that?
This need not mean stopping anyone doing what they're doing. It merely means someone exploring alternatives on the side.
I've been wondering whether there's any way to encourage this.
E.g. by crowdsourcing a prize for an annual competition for the best JS-less website or something.
Use all the latest shiny in HTML 5, CSS as well if that's what people want -- the last time I designed a web page, CSS hadn't been invented yet, so I know nothing about it -- but no PHP, no Javascript, no scripting at all. Flat static web pages, but using the power of modern computers and browsers to make 'em look nice and work well.
I'm aware of things like this:
But rather than arbitrary size limits, I am thinking of technological limits.
An unanswered question for me is the server side: is serving it from some whizzy dynamic engine that assembles the pages on the fly OK? Or is that a whole different target?
Should it be low-tech, i.e. static content only?
Or should it be high-tech, but only on the server?
I tried to stick to documented history only, so I am not sure what there is to disagree with TBH, but, er, OK. :-)
The thing is that minicomputers sort of got squeezed out by history, and the final stages of that were as messy as the metaphor hints.
So on the one hand, micros expanded to occupy the niche, and some micros can actually run minicomputer OSes, so does that mean that those micros became minis?
This becomes a philosophical question. For comparison some people like to say "dinosaurs never died out, because birds are dinosaurs!" Well, kinda, yes. But birds are one small type of dino. There are no 4-legged birds, no birds with working forelimbs other than wings: no arms, or hands, or gripping claws, or walking forelimbs; no birds with teeth; no truly herbivorous birds; and so on. One small branch of the dino family survived, and prospered and thrived and is doing great, but it doesn't represent the profusion of types of dinosaur there were.
Well, yes, late minicomputers had networking, could drive fancy graphical terminals and so display graphics, and some were powered by CPUs that had been shrunk onto a single chip... but they evolved from a different line of devices and convergent evolution gave them some microcomputer-like aspects.
There were also PC-type devices like the Jarogate Sprite, with an x86 chip, a machine that ran Concurrent CP/M only, had a floppy drive and a hard disk, but could only be accessed over dumb terminals. It didn't have or support a display. You couldn't connect a keyboard to it. It was a small minicomputer built using PC tech.
Another example is Alpha Micro. Obscure now, so you've probably never heard of them. Here's the best site about them:
Alpha Micro made Motorola 680x0-powered computers, with a proprietary OS that was in effect a 3rd party clone of DEC mini OSes, especially TOPS-10 and RSTS/E. A notable feature was that the only removable media were tapes, but not computer tapes: VHS videocassettes. That's how software and updates were distributed: data, on a videocassette.
A small host machine with no keyboard, no display, no way to add them; a host that could only talk to terminals; a proprietary multiuser/multitasking OS and most apps written in compiled BASIC.
These are all attributes of a minicomputer. But it used microcomputer parts and processors.
Alpha Micro, Jarogate Sprite -- which is it: a mini or a micro?
Well, kinda, both...
A single-user minicomputer with a big hi-res graphics display, a local keyboard and mouse (probably attached over serial ports with a weird plug, because it evolved from a mini that only could talk to terminals)... available with a choice of CPUs, including proprietary, or 386s and 486s, or Motorola 680x0, but mostly fancy expensive RISC chips... but it acts like a mini, runs a mini-derived OS (usually UNIX)... and like a mini, it costs as much as a small house...
OTOH it's single user. Is that a mini or a workstation? Is a workstation a kind of microcomputer?
It's hard to say. Is a bird a dinosaur? It's hard to say.
But the key thing is that all the workstations are gone now. The last vestiges were late Sun workstations, most with Intel chips. All gone. IBM still makes POWER machines but not workstations. HP stopped when Itanium flopped.
Some of these companies still make server boxes with their RISC chips that evolved from minicomputer-type things. A server isn't a workstation, though. Workstations have big graphics displays, and late ones had fancy 3D cards to drive them, cards that cost as much as a small PC network on its own, and had more memory than that whole LAN put together.
Servers have cheap crappy PC-derived graphics chips that only show the firmware screen. You drive them over the network, possibly by some bodged-on "lights out management" card which pretends to be a serial terminal, captures output from the display, and then sends it over the network.
Ugly bodged hack of a tech, designed for PC servers that are at heart microcomputers with a frame buffer and a local keyboard, and that's the only way to access the firmware so the network-only server needs to fake and capture and redirect it.
Which makes that commodity tech, so you can bolt it onto proprietary servers that evolved from RISC workstations which evolved from minicomputers... so you use the ugly PC kludge in place of a device which, deep down in its firmware somewhere, actually would happily talk to a dumb serial terminal and doesn't need the ugly PC-originated hack.
The lines are blurred. It's not clear any more which is which.
IBM P series servers are POWER machines that natively run AIX. The POWER CPU line evolved from the RIOS/ROMP processor in the IBM RT-PC.
https://en.wikipedia.org/wiki/IBM_RT_PC
That's a deskside minicomputer with a processor complex made from 5 or 6 separate chips. But IBM marketed it as a workstation-cum-PC-replacement, and the Wikipedia editors even call its chip a microprocessor, which it definitely wasn't.
It's all rather confusing.
But i is still quite removed from the micro standards: POWER, EBCDIC, COBOL, RPG, 5250 terminals, and the SLIC/TIMI/LPAR abstractions.
The typical "micro" app would use x86, UTF-8, Java/C++/Rust/Go on top of a general public system like Linux.
Well at least both use 8 bits words, it hasn't always been the case.
I'm not sure if an IBM i system would really qualify this way, it's mini software running on downscaled mainframe hardware.
IBM i is probably the last mini out there, it will feel completely alien to someone coming from the microcomputer world (say, *nix and Windows, x86 and ARM).