Against Against Windows

Readers of this blog might have noticed that there have been oddly many Windows related posts lately. Also, despite the numerous disclaimers about results working really nicely on Linux, a lot of screenshots have also been Windows. So... what is going on here?

Does this guy actually... you know... like Windows or something?

(gasp)

How did this even happen

Switching between Linux and Windows typically happens in the direction of Windows to Linux. After all, so the common wisdom goes, one of the main reasons people are still using Windows is because they haven't learned how to use Linux yet. It's the easy, default, boring option.

Would you go with it if you just want to get things done without too much tinkering / you need a piece of software that only runs there / are forced to use it? Yes. But it's not especially... inspiring.

Or... is it?

Here are some reasons why I think Windows is cool.

Not just as a tradeoff, but as its own thing.

(Most people using Windows probably haven't even realized these are things you could think about.)

Nostalgia.

Well OK, start with the silly one.

High school is pretty much a formative experience for many of us. I presume this is why they try so hard to instill a love of high literature and history in you. Well, part of the reasoning is pretty solid: songs that you listened to a lot back then still bring back a lot of memories... and which newer songs have a hard time competing with.

Well, maybe, my high school ended up persuading me that, in some deep, emotional way, I should become a Windows NT 4.0 sysadmin when I grow up. I don't think this was their exact intention... it was a great success nevertheless.

Back then, Linux was the system that you could actually understand and poke at. Meanwhile, Windows was this black-box thing that computer labs had. And, of course, students didn't have admin access. As a result... while becoming the one and only weird Linux fanboy in the entire school who would appreciate that one picture with Bill Gates of the Borg, ...

... there was also some curiosity about what's exactly going on in Windows, hidden behind MSDN subscriptions and overly expensive books. What are Control Panel applets, really? What's going on with all those long hexadecimal string things that look like {21EC2020-3AEA-1069-A2DD-08002B30309D}? Is explorer.exe just a program, or is it somehow built into the system?

Well, the docs are all on the internet now & you can buy said books for $5 on Thriftbooks.

Some people buy 40 year old mainframes for cheap for their basement, to pretend being a bank. Well, I just install Windows.

A nice GUI API

Is the Win32 API actually nice?

I did already argue that using it is not as arcanely complicated as you would think if you're not really familiar with it. Well... it's probably still more complicated (on the surface) than writing it in GTK or Qt or something supposedly friendlier.

Is it simpler though?

In the same sense as writing a webpage with the same UI controls is absolutely not simpler, despite involving fewer lines of code?

There is a feel to Win32 where they're not hiding much from you. There is a message loop (yes you're often literally writing a loop pumping messages), you're processing messages, you're calling API that is sometimes a bit ugly... but yes, you're drawing that actual button. There is no compatibility layer that works on Windows and X11 and Wayland and who knows what; there is no threads in the background that do obscure things, you don't have to link exactly against version 5.12 of your GUI toolkit that is 87 megabytes. I... don't even mention the part where there are some (supposedly) native apps that ship an entire copy of Chrome with them.

You can produce an executable that's literally 30 kilobytes, will start up in a negligible amount of time, and will run on anything remotely modern.

It will probably run on more Linux distros than any GUI that you could compile natively for them (hello wine!)

(Of course, you could argue that packaging & compiling them for every distro is something that would happen anyway; ... or you could argue otherwise.)

Another argument for Win32 is that it's been pretty much stable for the past, well, 30ish years? Stuff that you write now will likely keep working for another 20.

This is the way Emacs & Common Lisp feels like; you can learn it once. (It's also very much unlike... anything Javascript.)

This has multiple benefits. Among them, a fairly new one: LLMs know it impressively well. This also negates the downside of it being kinda tedious to call ugly C functions: you actually want a bit lower level if it's not you writing it.

Extensibility

Part of the appeal of Unix-like systems is that you can compose the tools in them in interesting ways. The Unix philosophy has it backwards though: it's not that you can get a flexible system out of small and focused tools, but that it's the right interfaces between components that enable these tools to stay sharp & focused. In the case of the Unix command line, this is "everything is a stream of text lines".

In a way, Emacs is extensible because of similar reasons. The model is a bit more complex here: there are buffers of text, shown in windows; there might be processes associated with them, there is standard-ish ways of doing syntax highlighting, etc.

Well... as it turns out, Windows has quite a few of these gems. Starting with the Registry; instead of having to add a config file parser to every single utility, you can just read from (and write to!) a neat tree of configutation values. (Now, imagine this tree being actually nice; there... might be some cultural issues with not ever expecting users to look at it.)

Another interesting area is the Windows Shell. There are entire git clients implemented as a shell extension, giving you info about the status of files & letting you make a commit out of them right in an Explorer window. One could also reuse this to replace the bookmark managers in browsers with something that's a lot more capable. If what you're doing is 80% file browsing and 20% something else, maybe you shouldn't build a file browser?

Plus... take the favorite promise of the 90s, OLE Automation / ActiveX / whatever fancy brand name of the day they were calling the system where you could embed documents in other documents and use custom controls in your Visual Basic app. Isn't this the true Unix way? If you want a fancy GUI control to draw graphs, should you download Graph Visualizer Pro (TM) and explain it how to draw your stuff... or how about you just dropping a control into your Excel sheet that picks up the data from around it?

Yes, this is obviously a lot more complicated than "text lines in, text lines out"; it's probably also more complicated vs. if we just had Lisp Machines all along. But it's also more ambitious.

It's just different

Windows is a pretty terrible implemenation of Unix. Accessing a ton of tiny files is really slow. The terminal is questionable. Yes you can get some Unix-y tools with e.g. Cygwin, but... it's not quite the right thing either. Aren't Macs nicer? Yes they aren't straight Linux either, but... at least you can pretend it is?

Well. What if you just don't want to?

Isn't there something exciting about working with a system that is not Unix? And not even trying to pretend it is?

Unix is pretty cool. We likely shouldn't pretend that it's the best thing imaginable. We should at least explore other approaches. Oddly enough, despite it being strangely mainstream, Windows is one of these systems!

By having looked at COM, you can learn interesting things about binary compatibility that you wouldn't have seen otherwise. "Glue things together by RPC and throwing many things into the same process" is not quite the same as "glue things together by piping them into each other and passing around file descriptors" as in Unix; isn't it interesting to see how this plays out?

But... of course, all of this is closed source. How are you supposed to learn from something that you can't even look at?

Well... not everything is lost. While Windows itself is closed source: have you heard of ReactOS? It's an open source reimplementation of an NT-like operating system; it's not (yet?) the best day-to-day usable system ever, but if you'd like to see an alternate-history version of how Windows 2000ish could have been implemented, it's there for you to learn from!

For example, this is their keyboard settings dialog. Want one that looks different? Just go and edit it!

And maybe, one day, the choice will be between "the Unix-like Free Software operating system" and "the Windows-like Free Software operating system".