Normally, when I film these videos,
I’m at the Centre for Computing History in Cambridge.
Unfortunately, it is April 2020 as I record this,
and times being as they are,
I have to make do with a green-screen.
But why simulate that same location?
I could be anywhere with this, right?
Well, first, this would have been a great subject to film at the computer museum.
But also: if I change things too much, it’ll break the style,
and people don’t like change.
Actually, that’s not true:
people like just the right combination of novelty and familiarity.
On that note: did you know that you can’t name a file “Con” in Windows 10?
...I promise that’s related.
If you’re running a Windows machine, try it right now.
Go to File Explorer, create a new folder, call it “Con”. C-O-N.
The system is not going to let you do it.
You also can’t name a text file “con.txt” or an image “con.jpg”.
Con is a first name, not a common English one,
but it’s a variant of Cornelius, Conrad, Connor, Konstantinos.
There are a good few people who go by the name Con.
So if you’re trying to save a photo of one of them
using their name on Windows, you can’t.
In fact, the system won't let you call a file or folder
CON, AUX, PRN, LST, COM0 through COM9, LPT0 through LPT9, or NUL.
And the reason for that goes back to MS-DOS,
one of the old white-text-on-a-black-screen command-lines
that were just how computers worked back in the 80s.
Actually, it goes back a bit further than that,
because all the versions of DOS were copying the idea from other places,
but let’s not go too deep into history.
In MS-DOS, Microsoft’s version of DOS,
all those little words are the names of “device files”.
They were a quick and clever way of letting programs on a computer interface with other stuff:
printers, keyboards, basically anything that you can plug in.
Rather than every program having to understand how to talk to every possible device,
that job was given to a “device driver”.
And that device driver…
drove the device.
So programmers didn’t have to worry about how every single type of printer worked.
Instead, they could reuse code that they already had for reading and writing files.
They’d just save whatever they wanted to print to the right “device file”;
it wouldn’t actually get written to disk,
instead the device driver would pick it up from there and do all the heavy lifting.
But the programmer didn’t have to care about how any of that worked:
as far as they were concerned,
they could just save a file and something else would deal with it.
And eventually, that meant that if a new printer came out
with a new, complicated, shiny feature on it...
the manufacturer would bundle a new driver with it.
All the old programs would still work,
they could just save stuff to the device file, same as they always did,
and the driver would deal with the messy real-world stuff.
And if you wanted a really, really basic way of using those device files,
you could do it with the command line itself.
If you typed in “dir”, you’d get a listing on screen of
whatever files were in the current directory or folder.
"D-i-r". They were called different things back then.
Add a redirect symbol, that angle bracket,
and instead of the listing going to the screen, it’d be saved to a file.
But if you tried to save it to a file called LPT1,
the system would spot that file name, and instead of going to the hard disk,
your listing would be sent to the device driver for the parallel port,
the one that was labelled LPT1 on the back of your computer.
The place where you probably have a printer plugged in.
So even knowing nothing about how the parallel port or printer worked,
you could just... print.
The side effect of that was: those file names were reserved.
You could not create a file called LPT1.
Or CON, which was short for “console”.
If you tried, you’d end up sending stuff to a printer or something instead.
Oh, and the really early versions of MS-DOS actually didn’t have the concept of directories,
or folders, as we now call them,
everything was just in one big heap of files.
When directories were added in,
those device file names still had to work everywhere,
which meant those file names had to be blocked everywhere too.
Same with con.txt, because file extensions were stored differently back then.
And there is a direct line from thirty-year-old MS-DOS to Windows 10.
Each version has built on the one before.
If you know where to look,
you can still find the Windows 3.1 file selection box from '92 in Windows 10 today,
and Windows 3.1 ran on top of MS-DOS.
Now, there aren’t many Windows 10 PCs out there with parallel ports:
but I bet there’s a few somewhere.
And Microsoft chooses to support them,
because of “backwards compatibility”.
Backwards compatibility means that you shouldn’t have to buy a new printer
just because you’ve got a new computer.
New stuff should also support old stuff, within reason.
The trouble is that different companies have very different definitions of “within reason”.
Video gamers are used to the idea of backwards compatibility:
sometimes games for older consoles will still work on modern ones.
But usually, it doesn’t last too long:
you can't play a Playstation 1 game on a Playstation 4.
At least, not by putting the disk in and expecting it to work.
The internal parts are so different that the designers would have to emulate the old system:
write a piece of software that translates between the old game and the new console,
changing the command calls on the fly,
or even just create an entire virtual Playstation 1 that sits in memory.
It can be done.
But the economic argument for backwards compatibility in games isn’t great:
if you support old games,
does that mean people won’t buy as many new ones?
Couldn't you just sell them a remastered version instead?
And if you want to emulate an earlier system,
you'll need to emulate everything.
Even the bugs.
To this day, Microsoft Excel thinks that the 29th of February, 1900 is a real day.
It isn’t. 1900 was not a leap year,
turn-of-the-century leap years are only leap years if they’re divisible by 400.
But when Excel first came out, in '87,
it was competing with a program called Lotus 1-2-3,
and that program had a bug where it got that leap year wrong.
So Excel copied that bug, for backwards compatibility.
And more than three decades later, that’s still the case,
it’s in the formal specifications,
it still gets that wrong because if Microsoft changes that buggy behaviour now,
they might silently break some really critical spreadsheet somewhere in the world.
Microsoft has always been the company of Backwards Compatibility.
It’s built into almost everything they do,
it’s part of the deal of why a lot of companies stick with Windows:
they will not need to change their workflow.
You can still open a Microsoft Word document from thirty years ago in the current version.
There are going to be folks out there, somewhere,
who still need to use a very old bit of software or hardware,
the sort of thing where the company that made it went bust decades ago, and for that to work,
it needs to read from a magical device file called CON.
So Microsoft, to this day, doesn’t let you save a file with that name.
Because it might break something.
It won’t last forever, of course.
At some stage, old systems do become too difficult or expensive to keep supporting.
Or maybe there's a direction that the company is trying to push their products in.
Mac and Apple users will know that all too well;
new versions of Mac OS often just don’t run old programs.
New apps, even simple ones, aren’t allowed on older phones.
Headphone jacks get removed.
People like a mixture of novelty and familiarity.
If you change nothing, people get bored and move on to something else.
If you change everything, people hate it, it breaks their workflow,
and they move on to something else.
Backwards compatibility, with reason, helps to find that balance.
So yes, I couldn’t film this video in the actual Centre for Computing History.
But, at least for a while,
I don’t have to go to an actual museum to run old applications and games.
Catalogues of software and the documents created with them can still be read,
even if the exact combination of hardware they were designed for isn’t available.
No-one’s expecting your iPhone to read punch cards, but sometimes,
a little backwards compatibility can be a good thing.