It can be deceptively easy to think of the bygone age of computing—the era of vacuum tubes and mainframes and text-only operating systems—as an ancient epoch that’s separate from today’s world of smartphones and touchscreens. In reality, that ancient history informs today’s tech in ways you probably wouldn’t think of, at least until you run into a bug that dates back to 1974.
Twitter user Foone regaled us with such a story over the weekend after encountering the following bug, an error message stating that a itty-bitty 9.57 kB file called AUX.H was somehow too large for the disk it was being transferred to:
It is 2018 and this error message is a mistake from 1974.
This limitation, which is still found in the very latest Windows 10, dates back to BEFORE STAR WARS. This bug is as old as Watergate. pic.twitter.com/pPbkZiE57t
— foone (@Foone) November 3, 2018
In fact, it’s not the tiny file that’s too big, but rather the possessor of a protected file name that Windows reserves for itself. The problem stems from a chain of backward compatibility decisions that Foone lays out in the lengthy thread, which you can read in its entirety here.
How could a problem dating from the days of Watergate afflict modern machines? The short explanation is that this limitation dates back to the early days of Unix, which adopted a programming paradigm of treating everything—from text documents to printers and keyboards—as though it was a file. It did so to simplify and standardize interactions between different “objects” in a single system.
Because of their hardware constraints, such early systems used multiple physical disks for storing files instead of what we’d use today—onboard storage divided into various digital folders. An emergent trend back then was that certain file names, no matter their file extensions and no matter their location on a system, would always refer to certain things.
Nah. It is. These special devices exist at all extensions, so that this works. so if “CON” is reserved to refer to the keyboard, so is CON.TXT and CON.WAT and CON.BUG
Eh. It’s a hack, but it works, and this is just on some little microcomputers with 4k of ram, who cares?
— foone (@Foone) November 3, 2018
As new operating systems were developed and designed to both borrow from and support programs native to their predecessors, the tradition continued—even as the world more or less left it behind. The result is that even in 2018, certain file names are still off-limits to the average user because Windows reserves them for other things.
This issue is not the bug itself. It’s just a bit of antiquated backward compatibility, and backward compatibility is a good thing in principle! The bug is the specific error Foone received while attempting to back up some files. The file isn’t too large to copy, its name is merely reserved. You can go see the correct error right now if you’re on Windows. Just open notepad and attempt to save a file as “con.txt”.
Following the thread’s initial popularity, Foone appended a few small corrections to the summary of the long, convoluted history. But the gist of the tale, minor inaccuracies and all, is still a fascinating window into the way the long arc of computer history still affects us today in small and large ways, be they the inability to create files with certain names, or the continued hegemonic domination of an outdated and inefficient filetype that countless programmers have tried to kill and replace, or a plucky Commodore Amiga that continued to run the heat and AC of 19 public schools well into 2015.
Underneath the shiny facade of iOS 12 or Android Pie or Windows 10 or macOS Mojave is a strange, tangled history of decisions that shape the technological universe as we see it today, whether you notice them or not. There’s nothing that’ll make you marvel at how we ever get anything done like lifting the hood to take a peek underneath.