A fun article but it is incomplete. It misses out on the company's height.
In the early days it has its own server OS, 3Com 3+Share. It was a multitasking file server OS and it was based on MS-DOS. Yes really. An internally multitasking server stack on DOS. I became expert in it in my first job and my 3rd job leant heavily on that and my skills.
It used the MS LAN Manager stack over NetBEUI.
It inherited DOS limitations like 32MB partitions. On PC servers everything had to for into 640kB of RAM and natively it could not use XMS, only EMS.
3Com offered a range of dedicated network file server boxes, the 3Server. The first was an 80186 and later the 3Server3 with a 386.
Then it got big into OS/2 and released 3Com 3+Open. The multitasking stuff obviated by OS/2 1.0's own built in multitasking but now it was multiprotocol and the server could run other stuff too.
The 3Server had no display, no port for one, no keyboard connector. It could only be administered over the network. It did have a little 1-line LCD display for showing a status message, accessible via a DOS device driver for showing custom messages. A physical rotating dial let you choose a station number at hardware level.
Some pics here, but not the models I knew:
https://www.bcsatellite.net/blog/pats-memoirs-design-time/
Because there was no display, that part of the 80186 memory map could be used for RAM, so a 3Server could give 800-900kB of RAM to DOS. A selling point: it could have 25% more memory than a PC and was arguably easier to configure.
The 3Server3 had for the 1980s very high memory limits, but we didn't sell many.
3Com's DOS apps had their own pre-CUA text-mode windowing and menuing system, 3+Menus, with a consistent UI and navigation keys, before Windows 2.0. Fill in fields in any order, Enter to accept, Ctrl+Enter to accept the whole dialog box, close it (with an animated zoom-out effect), and return to the previous level. This applied to all 3Com software and meant very fast navigation. Last seen in the DOS setup tool for the 3C589 ISA NIC.
As well as file and print, it bundled an email server client, which almost none of my clients ever used, and it also could act as a network gateway, with tools for WAN linking of networks into a big MAN, which I also never used.
I remember putting 3+Share on an IBM PS/2 Model 80 with the biggest hard disk I'd ever seen at that time: 330MB, on an ESDI interface. I had to partition it as drives C:, D:, E:, F:, G:, H:, I:, J:, K: and L:. All 32MB except for an 11MB L: drive.
NOS on C:, main network app on the next letter, data on the next letter, home directories on the next, print spools on the next... it tool some ingenuity to find ways to use them all on DOS 3.3.
There was only one supported big-partition tool, VFeature Deluxe from Golden Bow Systems, and none of my clients were willing to pay for it. GBS did various DOS addons: a software disk cache, VCache; a defragmenter, VOpt; and VFeature, for disk partitions over 32MB.
https://golden-bow-systems.software.informer.com/
I even tried installing it on Compaq DOS 3.31 which had big FAT16 partition support using the same system that MS-DOS 4 later adopted, but 3+Share could not see the big drives.
It was an interesting time. Learning all this stuff was just part of my job. My boss in my first job -- he died of cancer earlier this year; goodbye, Colin Sheard, you taught me a lot -- said to me in 1988 something like "PCs are fun, but it's networking where the really interesting stuff is these days."
Compared to 21st century stuff, there was a little more complexity. TCP/IP was not yet standard and most office-level networking didn't talk TCP/IP. It was very expensive, complicated, fiddly, and so 1980s and early 1990s computers. just avoided it. We didn't use it at all.
There's a _lot_ of historical revisionism. Some of the Wikipedia articles are clearly edited by people too young to remember the time when PC networking caught on, and they don't believe the stories from back then and have edited them and changed the facts to fit what "everybody knows" these days.
So, no TCP. I worked in 5 full-time jobs in 2 countries, and set up and worked on hundreds of networks in multiple cities, different equipment, different industries and market sectors. I'd been building LANs and networking up businesses' PCs and Macs for decade before I ever saw TCP/IP.
No TCP/IP at all anywhere. Nobody cared. It was some complicated Unix thing and if you ran business computers they didn't run Unix or if they did they weren't networked so they had no network stack.
Forget the stories of "industry giants" like Sun or whatever. Only universities had them, spending someone else's money on these fantastically expensive American toys.
Before Mac OS X the world's most-successful best-selling commercial Unix was SCO Xenix. They sold millions of units. Xenix did not come with a C compiler, or X11, or a network stack. All of these were separate expensive optional extras so you didn't buy them if you didn't absolutely require them.
In America local telephone calls were free. In the rest of the world, local calls cost money. So, few BBSes, little use of download sites in the modem/dialup era: it was too expensive.
Countless hundreds of thousands of isolated standalone Unix boxes talking only to dumb terminals over RS-232, and backing up to tape drives or floppies. Even more standalone PCs, with the entire network in 1 building and no links to outside.
No comms = no security problems = no patches and no updates.
So, in real corporate life, what network protocol you used depended on whose kit you bought. Use Novell server OSes? Then you ran IPX/SPX. That's what Doom ran on.
Use Microsoft (and IBM) PC server OSes? Including 3Com? Then you ran NetBEUI. Wikipedia is wrong: it's not an API, it was a protocol.
Use Macs? You ran Appletalk (for file/printer sharing) over Appleshare (network protocol, over Localtalk (RS-423 cabling) or, later, Ethernet.
Use DEC VAX servers on the backend? Then you ran DECnet.
Really rich multinational, HQ in America? Maybe Banyan Vines, and you ran XNS. Never saw it in real life.
Use IBM big iron? Then you were rich and didn't use toys like PCs and Macs.
There were smaller ones too, like weird peer-to-peer networks that invented their own cabling, interconnect, protocols, everything. LANtastic. The $25 Network. SAGE MainLAN. Personal Netware. Netware Lite. (The latter 2 different and incompatible.)
Lots of protocols.
Only after Win95 and NT came along were OSes mainstream that could run more than one protocol at a time. In the DOS era, it took too much memory.
Now things are simpler on that one front -- "it's always DNS" just means it's always TCP.
But the OSes were in the tens of MB to maybe 100-200MB in size. The entire OS came on a 2-digit number of floppies holding 1.4MB each so there was a cap on size, and they shipped mostly fairly well debugged. It was common for companies to run version-point-zero products for years, unpatched and unupdated ever, because they worked.
When the OS is that small and relatively simple, with no VMs, no mix-and-match hypervisors, no containers, no stream of dozens of updates a day, it was easy to get to know both ends of the wire inside out and know exactly what they did.
When TCP/IP started to come in, in the late 1990s, over dialup at first, in came waves of malware. At the same time, OSes switched to shipping on huge optical media, and the pressure to keep them small and simple went away, so they got big and bloated fast.
And with that, along came dial-up internet, then from 1999, broadband: half a megabit a second, if you were rich. So, you could update the deployed software in the field. Result: it didn't have to be small and it didn't have to work, so it immediately stopped being small and stopped working at the time it shipped.
Ubuntu is to me one of the newest big Linux distros. It launched in 2004. I switched from SUSE to Ubuntu that year. When Ubuntu launched, it came on CD, and it took so little room -- just 300MB or so -- that Canonical filled the rest of the CD with Windows installers for all the apps bundled in Ubuntu. You could get used to the apps (Firefox, Thunderbird, LibreOffice, Pidgin, VLC, etc.) first, and then replace Windows with Ubuntu once you knew the apps.
Soon it filled the CD. A few years later it switched to DVD. Then it filled the DVD. Now it no longer fits on a DVD.
Apple switched to dual-layer DVDs -- much harder to copy. Microsoft invented various bogus "activation" systems. The pirates, weaned on Amiga games a decade before, just cracked them. So MS stopped updating pirate copies and thereby invented a vast malware industry and sabotaged its own products.
CD-ROMs, modems, and TCP/IP began the Great Enshittification. It applies to FOSS every bit as much.
Now, LLMs will blast apart those vast complex stacks of buggy junk, shooting them full of holes like the shielding bases in Space Invaders.
At the same time...
And the genAI bubble collapses, bankrupting lots of industry giants... but the tech scales down to high-end PCs.
As the same time...
China has its own chips and OSes, and while they aren't very fast, they are good enough. So it can get away with invading Taiwan and destroying the world chip industry.
Meanwhile climate change will destroy many of the chip and component making plants: the biggest El Niño in 1000 years is about to obliterate a lot of Asia.
Meanwhile, America tears itself apart in civil war, and the Gulf Stream collapses and Europe starves while it freezes. Nobody else can make chips or pay to maintain these vast fragile swiss-cheese OS stacks.
At the same time, chips get slower and memory gets much smaller, as the rest of the world has to make small cheap fabs, not the huge nanometre-scale ones that cost hundreds of billions and take decades to being online. Big fast computers get very expensive again, and stay that way.
With any luck, it will become impossible to deploy anything that is more than a few tens of thousands of lines of hand-inspected code, because a bot will prise it open in at most a few days and pwn you.
So we'll be back to double-digit megabytes RAM and megaHertz class CPUs, if we're lucky.
(Repurposed from HN and Lobsters.)
I think there are many.
Some examples:
* The fastest code is the code you don't run.
Smaller = faster, and we all want faster. Moore's law is over, Dennard scaling isn't affordable any more, smaller feature sizes are getting absurdly difficult and therefore expensive to fab. So if we want our computers to keep getting faster as we've got used to over the last 40-50 years then the only way to keep delivering that will be to start ruthlessly optimising, shrinking, finding more efficient ways to implement what we've got used to.
Smaller systems are better for performance.
* The smaller the code, the less there is to go wrong.
Smaller doesn't just mean faster, it should mean simpler and cleaner too. Less to go wrong. Easier to debug. Wrappers and VMs and bytecodes and runtimes are bad: they make life easier but they are less efficient and make issues harder to troubleshoot. Part of the Unix philosophy is to embed the KISS principle.
So that's performance and troubleshooting. We aren't done.
* The less you run, the smaller the attack surface.
Smaller code and less code means fewer APIs, fewer interfaces, less points of failure. Look at djb's decades-long policy of offering rewards to people who find holes in qmail or djbdns. Look at OpenBSD. We all need better more secure code. Smaller simpler systems built from fewer layers means more security, less attack surface, less to audit.
Higher performance, and easier troubleshooting, and better security. There's 3 reasons.
Practical examples...
The Atom editor spawned an entire class of app: Electron apps, Javascript on Node, bundled with Chromium. Slack, Discord, VSCode: there are multiple apps used by tens to hundreds of millions of people now. Look at how vast they are. Balena Etcher is a, what, nearly 100 MB download to write an image to USB? Native apps like Rufus do it in a few megabytes. Smaller ones like USBimager do it in hundreds of kilobytes. A dd command in under 100 bytes.
Now some of the people behind Atom wrote Zed.
It's 10% of the size and 10x the speed, in part because it's a native Rust app.
The COSMIC desktop looks like GNOME, works like GNOME Shell, but it's smaller and faster and more customisable because it's native Rust code.
GNOME Shell is Javascript running on an embedded copy of Mozilla's Javascript runtime.
Just like dotcoms wanted to dis-intermediate business, remove middlemen and distributors for faster sales, we could use disintermediation in our software. Fewer runtimes, better smarter compiled languages so we can trap more errors and have faster and safer compiled native code.
Smaller, simpler, cleaner, fewer layers, less abstractions: these are all goods things which are desirable.
Dennis Ritchie and Ken Thompson knew this. That's why Research Unix evolved into Plan 9, which puts way more stuff through the filesystem to remove whole types of API. Everything's in a container all the time, the filesystem abstracts the network and the GUI and more. Under 10% of the syscalls of Linux, the kernel is 5MB of source, and yet it has much of Kubernetes in there.
Then they went further, replaced C too, made a simpler safer language, embedded its runtime right into the kernel, and made binaries CPU-independent, and turned the entire network-aware OS into a runtime to compete with the JVM, so it could run as a browser plugin as well as a bare-metal OS. Now we have ubiquitous virtualisation so lean into it: separate domains. If your user-facing OS only runs in a VM then it doesn't need a filesystem or hardware drivers, because it won't see hardware, only virtualised facilities, so rip all that stuff out. Your container host doesn't need to have a console or manage disks.
This is what we should be doing. This is what we need to do. Hack away at the code complexity. Don't add functionality, remove it. Simplify it. Enforce standards by putting them in the kernel and removing dozens of overlapping implementations. Make codebases that are smaller and readable by humans.
Leave the vast bloated stuff to commercial companies and proprietary software where nobody gets to read it except LLM bots anyway.