John Vert

@rfleury controlling the "semantics and lifetime" is a double-edged sword, as now you have to figure out (and follow) the rules. Everybody already knows and agrees on the rules for the lifetime of stack-allocated memory.

"The stack" is a per-thread address space range, dynamically reserved by a kernel when a thread is created. The reason why "stack" is often presented as preferable to "heap" is that, when using a thread's stack, the expensive part of allocation - address space reservation, and preparation of physical pages for backing the address space - has already been performed when the thread was created. But kernels also provide mechanisms for doing your own address space reservation (mmap, VirtualAlloc), and there is nothing stopping you from using these to do bulk allocations up-front to create your own stacks. This can make common case allocations as cheap as "the stack", but the advantage is that you now control the semantics and lifetime of the stack you've created. Thus, it does not need to be coupled to - for example - the lifetime of a scope or function, as the thread stack is. The "stack versus heap" dichotomy is an unfortunate mythology because it seems to, in practice, communicate the idea that when a thread stack is insufficient for some purpose (allocations must exceed scope boundaries, allocations may need to exceed thread stack limits, allocations require more fine-tuned reserve/commit behavior, and so on), then the only alternative is the heap, particularly for very granular allocations. This is, again, a mythology, and it has confused the C++ world in particular for decades.

@cougsgo I am in Bend and it is working for me on mariners.tv

Why would tonight’s game be blacked out in Bend when I paid for every possible MLB package, including MarinersTV. Anyone know why that is? Thanks. #GoCougs

@eramajaarvi @stevesi React native might be a reasonable tradeoff for cross platform UI but building the start menu in JavaScript is unhinged

@jvert @stevesi some parts of the start menu are react native, electron is a completely different thing

This is all true. Link below to read why we tried to create a new API in Windows 8 and why just porting to ARM doesn't work if the old APIs still work the same way if we want battery life + always connected + security + fatless + quality over time, etc. web.archive.org/web/2012020921…

@marklucovsky Self hosting was also an important part of getting real world testing.

2/ The architecture work happened differently. The kernel/executive team was extremely tight-knit. If you touched kernel code, it was your responsibility to know what Dave Cutler, Steve Wood, Lou Perazzoli, Mark Lucovsky, Landy Wang, etc. were doing. Design review mostly happened socially: hallway conversations, short design docs, active integration/debugging sessions. We moved fast. A feature like I/O completion ports could span kernel, I/O manager, executive, ntdll, and Win32 layers — and major chunks could come together in days because there was enormous trust and constant communication. The “review” often happened after checkin during integration and stress. And yes, we had mitigation mechanisms. “Safe sync periods” where checkins were tightly restricted so people could actually achieve a stable enlistment/build. Near major milestones, checkin lockdowns became extreme. At one point, if you wanted a checkin during stabilization, you physically came to my office and wrote it on my whiteboard. If the board was full, you waited. Later we escalated to formal ship-room processes: real bug, real justification, approval from senior leads, then permission to check in. That wasn’t really code review. It was change control. Different era. Different tooling. Different scale constraints. But one thing David’s piece gets right: A lot of software quality did not come from pre-commit review gates. It came from tight teams, deep ownership, brutal integration pressure, system-wide stress, and developers who fully understood the machinery they were standing on. crawshaw.io/blog/agent-pri…

In David Crawshaw’s (@davidcrawshaw ) recent post “The agent principal-agent problem” there’s a lot of insight beneath the headline “Code review is broken.” Worth reading carefully. Toward the end, David reflects on what he calls the old “cowboy” development culture at Microsoft in the 80s/90s. Not much has been written about that era, mostly because there was no social media, no laptops everywhere, no phones recording daily engineering life. A few thoughts from someone who lived it. Back then, formal code review was not our primary line of defense. Our biggest daily problem wasn’t “is this algorithm theoretically perfect?” It was: Will the full system compile? Will it link? Will it boot? Will it survive stress? Pre-Win2k we used an internal source control system called SLM (“slime”). No branching. Filesystem-based. Extremely brittle. To build a bootable NT system you needed 100+ SLM projects welded into arbitrary places in the tree. Getting a machine synced could take 3+ hours. You literally ran sync in a loop until you got no new files and no errors. Then came the build. In the NT 3.1 timeframe, a full system build on a capable machine might take ~5 hours. By the Win2k era, full builds had stretched into the 14+ hour range — and this was before modern build farms or large-scale distributed compilation. Those build times fundamentally shaped developer behavior. Most developers avoided full-system builds entirely. They worked in tiny enlistments and borrowed objs/binaries from known-good systems because rebuilding the entire world was simply too expensive in both time and productivity. The longer builds became, the more pressure there was to take shortcuts — and those shortcuts created endless opportunities for integration failures and subtle mistakes. A broken build could easily waste days of engineering time. In bad stretches, you could go multiple days without a clean master build. That approach worked… until someone changed a widely shared struct, renamed a field, added a property, tweaked a macro, or silently altered alignment assumptions somewhere deep in the system. Best case: parts of the system no longer compiled. Next best: they compiled but failed to link. Worst case: everything built successfully, but incompatible assumptions between old objs and newly compiled code poisoned the running system in ways that were extremely difficult to diagnose. THIS was our daily battle: not bad style, not missing comments, not minor logic bugs — it was preserving system-wide build and runtime integrity across a massive codebase when most developers could not practically build the entire system locally. Once we had builds that compiled, linked, and booted, the real work started. Stress. Every dev had at least two machines: one for coding, one for testing/stress. We hammered systems continuously with unrealistic randomized load. Deadlocks. Pool corruption. Loader hangs. Resource exhaustion. “Hung, No Ready Threads.” In the early days, the stress build was literally my build. I’d walk office-to-office in the morning checking which machines had died overnight and assign debugging work. No remote debugging yet. If someone needed your machine, you lost your office for hours. Eventually we got remote.exe and centralized build/stress systems, but debugging was still brutal: raw assembly, minimal symbols, hand-reconstructed stacks, careful avoidance of paged-out memory because one wrong move killed the session. That was the real engineering culture: integration, stress, performance, resource correctness, system behavior under extreme load. Most of the failures we chased would never have been caught by lightweight pre-commit review from someone inside your immediate group.

@ivanrouzanov The image of Cutler pecking away at his keyboard with his own personal tape drive humming away behind him is frying me 🤣

Is it true that Longhorn was an absolute disaster? Yes. Is it true that Vista was reset back to Server 2003 SP1? Yes. But was it DaveC backup tapes? No, this is not true. All the code was in the source control, we just started a new branch. No backup tapes from DaveC.

@tylerangert Ok!

@jvert Missed the point completely!

What’s funny about the industry stigma against frontend work is that before the internet, basically all programming was “frontend” in a way. Eg it was all about graphics, local performance, proper memory management, etc. sort of “back of the frontend” work all baked together. The service-ification of algorithms + compute has created an artificial divide between where “real work” lives software

@bcardarella lol how many people do you think worked on NT3.1 kernel?

This is such a complete misunderstanding of how complicated it was to do this within Microsoft when he did it. Plotting telemetery is one thing. Getting the largest software vendor, at the time, to coordinate that all software within needs to play nice with this one tool is not.

@Titan_JS_ @SandyofCthulhu Lol we literally loaded trays of donuts into trash bags. If you think the organizations threw them out, I think you are quite disconnected from the reality of some people's lives.

@jvert @SandyofCthulhu If you donated sealed boxes of donuts, those organizations can say they were not aware of the origins of the food and can hand them out. If they were loose or open packages they most likely ended up back in the trash.

Okay let's discuss why Krispy Kreme does this: 1) obviously, they miscalculated how many donuts to make that day. They don't WANT to waste the food. Since you can't predict your customers, sometimes you will have too much food. 2) Because they're a business, they can't just hand out the donuts for free at day's end, or they won't be able to sell them. 3) So the solution is "give them to charity". The problem here is that the litigious nature of modern America means that they will absolutely be sued when some moron chokes on a pecan chunk. It's not worth the risk. 4) The next step is to argue "The law needs to hold Krispy Kreme guiltless if they give away their extra food." That all sounds fine and well, BUT I guarantee that the city will have a whole list of rules a food donation has to follow to be immune from lawsuits. And Krispy Kreme has clueless teenagers throwing out the donuts, so they will absolutely fail to follow all the rules. 5) the only way this could readily work in the USA without being crushed under the burden of bureaucracy or lawsuits would be if each individual Krispy Kreme had a specific charity who came by at night to pick up the extra donuts. People they knew and trusted. Get rid of the lawyers and allow for common sense and that food can be donated lightning fast.

@eeuoss I would never take an engineer seriously who can't figure out what files are taking up space on a filesystem regardless of the OS.

My girlfriend Windows pc crashed. Drive is full. With “system files”. I don’t see a way to clean it up. She’s finally ready to move to normal OS. I don’t understand how people can use this shit. I would never take a software engineer seriously if they are on Windows.

@davepl1968 Didn't you go to school in Canada? Absolutely watched this in the school cafeteria.

99.9% of people who "experienced" the Challenger disaster saw it on replay and now remember it as live. Almost NO ONE was watching. Everyone thinks they were. It's a fascinating collective false memory.

@marklucovsky @housecor the policies sometimes involved breaking shit... like office walls

@housecor Windows NT was built without formal code review… But we also had some pretty aggressive policies around breaking shit

Just learned a team at Microsoft is doing code reviews *after* merge. Why? To move faster. No more pausing work to wait for code reviews. No need for stacked PRs. No more time-consuming merge conflicts caused by long code review delays. This has risks, but may work well for a team that is: - mature - high trust - has strong automated quality checks

@allie__voss Basically like going to a big concert or sporting event today (without the ticket check) just walk through the metal detector.

As someone who never experienced airports before 9/11...was there truly NO security? Like you could just walk wherever like a train station?

@jujubileen SteamOS 😁

@jvert which one will give me the most clout

I've got to get a new laptop as my charging ports are finally kicking the bucket. (I'll be using my old one to run a local AI model) Deciding between replacing my old one (Lenovo X1 Carbon i7) or trying out a macbook (probs macbook air M1). I love my thinkpad because of the mechanical keyboard but the webcam is potato quality and I honestly have been so unhappy with the aesthetics of recent windows updates anyone have thoughts??

@jujubileen Which Linux though

@jvert 🧐you're on to something. But it's sad, will be an end of an era but then I can finally switch my Lenovo to linux for our new family agent Botson to use...Arthur is not ready but I am

@jujubileen So you can make sick iOS apps. Windows has turned into copilot slop and Arthur's not ready for Linux

@jvert for real why

@marklucovsky @davepl1968 to be fair, using plain C you can still get into a lot of trouble in multi-threaded environments with pre-emptive multi-tasking (and exceptions)... C++ just makes it easier to hide the trouble in constructors/destructors/overloaded operators & functions.

Some of the angst might have also been due to GDI initially and then made worse by GDI in kernel mode. I think they/we all learned a lot about how much trouble you could get into using C++ in multi-threaded environments with pre-emptive multi-tasking. Remember that phase where they used to take out locks in constructors and released them in destructors — just because. That’s probably part of the issue with number 3… Every morning I’d have a pile of stress failures: “hung no ready threads” — 96.4% of these where due to holding locks across callbacks or holding a lock and then calling a function that queued some work and the worker would need to same lock. AI would have done a better job than some of the folks we worked with back in the day…

I had this conversation at Microsoft in 1996: Me: "Why do we have our own pointer array code?" Mgr: "Because it's solid and well tested." Me: "So is vector<> in the STL!" Mgr: "Devs don't know the STL" Me: "They're devs, they should know the STL!" Mgr: "That's great, but they don't, so no." And so we continued to use and write all of our own containers and so on. Because the STL was scary.