top | item 36699115

Windows: A software engineering odyssey (2000)

180 points| xo5vik | 2 years ago |usenix.org | reply

101 comments

order
[+] jstanley|2 years ago|reply
What's crazy about this is that it sounds like the people writing the code haven't got the slightest hope of even compiling it, let alone running it. They're just writing code, crossing their fingers, and committing it.

It's a wonder the thing ever worked at all.

[+] yokoprime|2 years ago|reply
There’s a slide saying few developers could build a whole instance of win2000, but when working at this scale you rarely build everything from scratch locally. You work on your module and the build system will have to build everything nightly. I don’t read this as devs throwing completely unchecked code into source control.
[+] 13of40|2 years ago|reply
In the early 2000s, there was no integration between the Windows build environment (Razzle) and Visual Studio. It was common for a dev to keep their own .sln file on their dev box so they could work on their component, while the actual build happened against a I-cannot-even-remember-what file that the Razzle environment used.
[+] LispSporks22|2 years ago|reply
Can’t imagine how these Windows engineers feel about the enshitification of their baby. So much time invested into it - must be hard to see it taking this current trajectory.
[+] lozenge|2 years ago|reply
The kernel is better than ever. As for the shell, it's always had junk on it for commercial reasons - remember MSN and baking IE into the OS, or how the system requirements were ridiculously low for the reasons of marketing and to placate OEM manufacturers? And how OEMs were allowed to add loads of junk software on computers wearing their "Designed for Windows" stickers?

I'm pretty sure XP came with a digital app store right at the top of the redesigned Start menu, Windows Media Player had ten music stores integrated all selling DRM'd WMA files...

The system requirements especially, must have created a lot of work right down into the kernel team.

[+] distcs|2 years ago|reply
> Can’t imagine how these Windows engineers feel about the enshitification of their baby.

I think people are forgetting how unreliable Windows was in its early days. If you were doing anything complex (programming, editing pictures, ...) Windows couldn't run for 2 hours without crashing every so often.

If anything, the core of the Windows operating system has only gotten better with time. Yes, they keep adding fluff to the desktop environment but that doesn't take away the progress they have made in stablizing their core operating system.

[+] anaisbetts|2 years ago|reply
A core piece of enshitification though is that a product becomes Less Useful over time - Reddit and Twitter lose third party apps, Apple is making its desktop OS more "secure" (read: convoluted and does less stuff) every release. The things you Liked about it, goes away.

Windows, despite its legitimately annoying monetization strategy, has absolutely done the opposite - it does More Stuff every release, and the stuff it did before largely still works.

[+] muricula|2 years ago|reply
A few years ago when I was there, there were still remnants of that same Dave Cutler NT culture, especially around the folks who worked on minkernel/.

I agree there are definitely shitty chunks Windows, but there are still some very solid foundations there to this day.

[+] gigel82|2 years ago|reply
Source Depot was still a thing in Office as of last year when they finally transitioned to Git. Windows started transitioning to Git 5 years ago.

Also, they have about 10k people working on Windows (and devices) and about 10k people working on ads nowadays (that paints a good story of priorities).

Source: 2nd hand from MS friends

[+] com2kid|2 years ago|reply
Source Depot's largest disadvantage VS git how hard it is to share changes with others.

But I miss the ability to only pull down a portion of a monorepo, and the ability to remap where folders are at, or to pull down a single folder into multiple locations.

So much bullshit in with monorepos in Git land exists because Git doesn't support things that Source Depot (and Perforce I presume) supported decades ago.

As an aside for those who don't know what I am talking about, when pulling down a repo in source depot you can specify which directories to pull down locally, and you can also remap directories to a different path. This is super useful for header files, or any other sort of shared dependency. Instead of making the build system get all funky and fancy, the source control system handled putting files into expected locations.

So imagine a large monorepo for a company and you can have some shared CSS styles that exist and they always end up in every projects `styles` folder or what have you.

Or the repo keeps all shared styles in a single place, and you can then import them into your project, but instead of build system bullshit you just go to your mappings and tell it to pull the proper files put them into a sub-directory of your project.

It is a really damn nice to have feature. (That also got misused a ton...)

[+] inglor|2 years ago|reply
Am still in Microsoft, was part of that transition and can confirm it.

We did move stuff we could to other git repos inside Microsoft.

SourceDepot is still running for some stuff and is still awful but git is working great.

> Also, they have about 10k people working on Windows (and devices) and about 10k people working on ads nowadays (that paints a good story of priorities).

I'm not sure I'm privvy to all information but looking at the org chart this part is false. The ads org is much much smaller than E+D.

[+] osullivj|2 years ago|reply
Zachary's Show Stopper covers this ground in a very readable manner, and gives a lot of useful detail on Dave Cutler's design ideas, and DEC VAX VMS background.
[+] easton|2 years ago|reply
Not sure why you were downvoted, but that book was excellent. Shows that people 30 years ago were having precisely the same problems on big software projects we have today.
[+] sylens|2 years ago|reply
This has certainly whetted my appetite for a deeper dive - what's a good book on the history of Windows (or even Microsoft), from the earliest days up until at least Windows 95?
[+] ForOldHack|2 years ago|reply
There are details here no one else would know. Why would there be only a single mention of Xenix, when Microsoft bet the farm on it, only to vapor it for 4+ (79 to 84) years and outsource it less than 3 years later. (87)
[+] bitwize|2 years ago|reply
Vapor? Xenix existed, and worked well, on the TRS-80 Model 16. Many small businesses basically ran on a Model 16 with Xenix back in the day.
[+] osullivj|2 years ago|reply
Remember it well. I wrote a custom graphics card device driver for some mech eng code that would never fit in the 640K limit imposed by DOS.
[+] hunterjrj|2 years ago|reply
Plug for Dave Plummer's youtube channel: https://www.youtube.com/@DavesGarage

Dave was an engineer on NT and creator of Task Manager and zip folders. Lots of interesting stories and anecdotes from that period on that channel.

[+] Kwpolska|2 years ago|reply
The built in zip folders that Dave wrote aren't something to be proud of these days, they are super slow and basic.
[+] yakubin|2 years ago|reply
Slide 19 doesn’t load for me.
[+] zczc|2 years ago|reply
Slide 19 content (from .ppt):

  Serialized Development

    The model from NT 3.1 -> Windows 2000
    All developers on team check-in to a single main line branch
    Master build lab synchs to main branch and builds and releases from that branch
    Checked in defect affects everyone waiting for results
Diagram:

  Developer
  Developer
  Developer
  Developer
    -> Single MainBranch -> Product Build Machine -> Product Release Server
[+] jamesfinlayson|2 years ago|reply
> Source control system (Windows 2000) > Branch capability sorely needed, tree copies used as substitutes, so merging is a nightmare

Ouch, and it looks like they only had version control with branching for the last nine months of development.

[+] inglor|2 years ago|reply
Branching is an overstatement. SourceDepot didn't _really_ do branching.

You had patches you'd float with "changelists" on top of enlistments. Each part large enough in thhe org (for example Excel or Word) gets a "branch" and it gets "forward integrated" and "reverse integrated" to the main "branch".

From your perspective the tool used to submit stuff (usubmit usually) you just push to the same branch as everyone else in your org and if your code breaks things it gets "backed out" by an automatic process.

Using git now is so much nicer.