Windows NT on 600MHz machine opens apps instantly. What happened? | Hacker News Reader

Windows NT on 600MHz machine opens apps instantly. What happened?

twitter.com

752 pointsdceddia667 comments

It blows my mind how unresponsive modern tech is, and it frustrates me constantly. What makes it even worse is how unpredictable the lags are so you can't even train yourself around it.

I was watching Halt and Catch Fire and in the first season the engineering team makes a great effort to meet something called the "Doherty Threshold" to keep the responsiveness of the machine so the user doesn't get frustrated and lose interest. I guess that is lost to time!

Even worse is the new trend of web pages optimizing for page load time. You wind up with a page that loads "instantly" but has almost none of the data you need displayed. Instead there are 2 or 3 AJAX requests to load the data & populate the DOM. Each one results in a repaint, wasting CPU and causing the page content to move around.

There was a small accordion in some Google search results that opened around ~1 second after the results page was loaded and I think it was the most infuriating thing ever. And we are talking about Google here.

The one where you would go to click on the first result and it would expand seemingly perfectly timed in between and you’d end up somewhere else?

I want to say some webpages actually do this to make you accidentally click on ads but I have no proof.

We A/B tested it, and the 750ms accordion produces maximum revenue. Why do you hate evidence-based decision making? /s

You jest, but that's exactly how you get plausibly deniable dark patterns. It's a numbers game.

Worse, sometimes the people who do it are completely unaware they are making a dark pattern, because they see the result of A/B test and convince themselves it's superior to what they think.

The ultimate version of this was done by Optimizely some years ago, where - let's assume here unintentional - bad UI design encouraged people to terminate their A/B tests early when the metrics favored the new version, leading to people without good understanding of statistics implementing dark patterns (or just stupid patterns), blissfully unaware that they've biased their own A/B tests so strongly that they could just as well be replaced by a piece of paper with words "NEW THING WORKS BETTER" written on it.

It maximizes their revenue until I decide to stop using Google. Joke's on them for not measuring long-term effects.

A/B testing is so gross. In other domains human experimentation of any kind, no matter how low risk, involves getting fully informed consent and ethics board approval before going ahead.

Experimental behavior manipulation, without even telling the subject they are part of a manipulation experiment? You would be chased out of the room and your reputation destroyed! Utterly unacceptable. But in webdev universe this is somehow seen as a totally normal practice.

This is exactly how users felt when Reddit ran A/B testing on their "feature" that forcibly signed out people on mobile browsers and said they needed to use the Reddit app to sign back in. I saw a crazy long thread of straight backlash about how messed up it was and how they aren't cattle to experiment on and how they didn't consent to that (which they prolly did in the T&C but no one reads that and actually understands what they're agreeing to).

Seeing as they were posting the backlash on Reddit, I'm guessing a lot of people downloaded the app to log in and Reddit said "Big Success!" when they checked the stats.

> which they prolly did in the T&C but no one reads that and actually understands what they're agreeing to

The GDPR's notion of informed consent really needs to be applied pervasively to all kinds of consumer contracts. If it's hidden in walls of text that the average user doesn't read it shouldn't count as consent.

I remember reading somewhere that if you actually read the TOS/EULA of every single thing you use, it would take your entire lifetime.

I really could see Apple adopting an approach from FPS games, where the phone applies a click to what was under your finger 1/4 second-ish instead of what's there when the click is recognized. Time-travel clicking.

But the real solution is better web page design.

My guess for this is that the average user doesn't parse text on pages as fast as more tech-savvy users. That delay is perfectly timed for the average user to grab their attention.

For me, I use google so often that I can rapidly parse information without really needing to read much of the text, the link just sort of 'looks' right. I've observed my wife reading google results and she is much slower and more methodical, probably because she doesn't google things 20+ times a day every day like I do.

That's how I end up misclicking, because i'm not working at the speed of a normal googler.

It is really annoying though, there are some css tweaks you can make using browser extensions to make that disappear if you're so inclined.

My goodness, that accordion needs to removed from their code base immediately.

A horrific piece of UI/UX/engineering/whatever.

That one ALWAYS foils me and I hate it and whoever created it.

Their new AI shit on the top of the sesrch results does this. It's slow AF and I'll sometimes have scrolled partway down the page before it farts a huge blob of text up top and pushes stuff I've already scrolled past back down past my finger.

I'm sure the person who wrote that accordion is quite good at solving leetcode tho! (only half joking)

> You wind up with a page that loads "instantly" but has almost none of the data you need displayed.

Which, in my mind, means it didn't load instantly. The page isn't loaded until all of the data is displayed.

> Even worse is the new trend of web pages optimizing for page load time

I don't disagree with your example, but optimising for page load time is as old as the graphical Web.

Yes, but back in the 90s the dominant idea was load the text as quickly as possible, then all the other junk can come later.

I thought the thing to optimize for is "largest contentful paint", which is one of the weighted factors used by https://pagespeed.web.dev/

This drives me crazy, especially because it breaks finding within a page. Eg. if you order food and you already know what you want.

Old days: Cmd + f, type what you want.

New days: first scroll to the end of the page so that all the contents are actually loaded. Cmd + f, type what you want.

Is just a list of dishes, some with small thumbnails, some without any images at all. If you can't load a page with 30 dishes fast enough, you have a serious problem (you could always lazily load the thumbnails if you want to cheat).

I miss typing / to search on pages. Ctrl-W still messes me up at times when using a terminal in a browser.

You can search with / on Firefox.

' will search in URLs, skipping plain text.

Unless you're on github.com, because it rather inconsiderately takes over `/`.

Firefox lets you use / for search.

vimium / vimium-ff

Firefox allows you to use / to start a conventional search.

As a bonus, in Firefox if you hit the ' key (apostrophe) you get a search that looks only within hyperlinks and ignores all the un-clickable plain text. Give it a try, sometimes it can be very useful

> New days: first scroll to the end of the page so that all the contents are actually loaded. Cmd + f, type what you want.

Only to discover that 2/3 of the matches are invisible text that's put there for $deity knows what reason, and the rest only gives you the subset of what you want, as the UI truncates the list of ingredients/toppings and you need to click or hover over it to see it in full.

Or even worse, Cmd + F doesn't work because the page is lazily rendered.

Twitter does that and I don't understand why. Do they think their js blob can figure out which divs to render faster than the browser engine itself?

I am in no way a front-end person, but my understanding is that it has to do with React and the way it maintains a virtual copy of the DOM.

Having Ctrl-F not work correctly is maddening and I hate it.

Nothing to do with React, it's a common optimization to improve performance with long lists. You only render the dom elements in the viewport, with some buffer. A common technique to achieve that is called "virtualization" or "windowing".

It's common enough that there were a couple browser proposals to deal with this and would address the Ctrl+F issue. I believe this has been merged into the CSS Containment spec, but at the moment it doesn't make windowing obsolete in every situation.

It's not even a technique limited to browsers. When I did Android development years ago it was a technique used in native list controls to reduce the overhead of them. Though in that case, there's no search based on what's been rendered like a web browser has. And of course if you did implement search, you could have that look at the underlying data, so it doesn't matter if it's been rendered.

But Web browsers already don't render off screen content right? I'm pretty sure I remember opening hundreds of megs of data in Firefox at one point without an issue. Or old reddit with RES has infinite scroll and you can go dozens of pages deep without a hitch. All while not lazily rendering the other pages.

Like GitHub's new code viewer! I have to load the raw text just so I can use Ctrl-F!

Someone should invent a way for a web server to return a representation of the text, complete with styling and formatting that the browser can use to render it.

Well, the tech stack is insane: Some virtual machine running a web browser process running a virtual machine for a html renderer which consumes a document declaration language incorporating a scripting language to overcome the document limitations trying to build interactive programs.

Actually much worse as Microsoft once did with their COM model, ActiveX based on MFC foundation classes with C++ templates, etc.

And to build those interactive programs somebody is trained to use React, Vue, etc. using their own eco systems of tools. This is operated by a stack of build tools, a stack of distribution tools, kubernetes for hosting and AWS for managing that whole damn thing.

Oh - and do not talk even about Dependency Management, Monitoring, Microservices, Authorization and so on...

But I really wonder - what would be more complex?

Building interactive programs based on HTML or Logo (if anybody does remember)?

And don't forget the UX designers armed with their figmas and alikes. The tech-stack is only one among a number of organizational and cultural issues crippling the field.

Howdoes figma contribute to laggy UI of the end product?

Notice that in this sub-topic we're talking more generally about causes for low-quality software -- laggy UIs being only one of the symptoms.

Figma contributes by enabling UI designers to easily author interfaces which look allegedly beautiful but are complex to build, test and maintain.

And the resources burned on building such esthetically pleasant piles of barely usable software could find better use on making it simpler, faster and more focused on user actual functional and non-functional requirements (much of them taking place on the server-side) instead of sugaring their eyes by throwing tons of code on their clients

Ironically these instant starting NT applications were often using COM.

As much as I hated developing with COM, the application interoperability and OLE automation is a form 90s tech utopianism that I miss.

Indeed.

On one project, I actually shifted quite recently from working on old-school, pre-Windows XP, DCOM-based protocols, to interfacing with REST APIs. Let me tell you this: compared to OpenAPI tooling, DCOM is a paradise.

I have no first clue how anyone does anything with OpenAPI. Just about every tool I tried to turn OpenAPI specs into C or C++ code, or documentation, is horribly broken. And this isn't me "holding it wrong" - in each case, I found GitHub issues about those same failures, submitted months or years ago, and still open, on supposedly widely-used and actively maintained projects...

same with C#

I too was once very excited that OpenAPI specs I had access to would save me untold hours in implementing an API for a service since I could pass them through a generator, only to find once I tried everything seemed somewhat broken or the important time saving bits just weren't quite ready yet.

That was about five years ago. :/

I think of the OLE demos every time I shove a google sheet into a google doc and realize it’s only a one way sync.

WinRT is COM under the covers

In some ways COM is pretty optimized. An intra-thread COM call is just a virtual function call - no extra overhead. Otherwise it's a virtual function call to a proxy function that knows exactly how to serialize the parameters for IPC.

>An intra-thread COM call is just a virtual function call - no extra overhead.

There was a time when a virtual function call was a lot of overhead

Even having a VMT is overhead.

Sometimes the COM interface is implemented as actual interface, where the implementing class is derived from another class and the interface. (in C++ the interface is just another class with multiple inheritance, but other languages have designed interfaces). Then the class even needs to have two VMTs.

Multiple VMTs have even more overhead. And with multiple VMTs, it is not just a method call. In the functions, this always points to the first VMT. But when a function from the VMT is called, the pointer points to that VMT. So the compiler creates a wrapper function, that adjusts this and calls the actual function.

when methods from the later VMTs are called , this points (non-virtual thunk)

Virtual machines don't add much overhead.

That may be so, although a VM on AWS is measurably slower than the same program running on my Xeon from 2013 or so.

But, more generally, the problem is that tech stacks are an awful amalgamation of uncountable pieces which, taken by themselves, "don't add much overhead". But when you add them all together, you end up with a terribly laggy affair; see the other commenter's description of a web page with 30 dishes taking forever to load.

My experience has been that HTML and making changes to HTML has huge amounts of overhead all by itself.

I don't dispute that very bad javascript can cause problems, but I don't think it's the virtualization layers or the specific language that are responsible for more than a sliver of that in the vast majority of use cases.

And the pile of build and distribution tools shouldn't hurt the user at all.

It's exactly the pile of layers, not "bad javascript" or any other single thing. Yes vms do add ridiculius overhead.

When half the layers add up to 10% of the problem, and the other half of the layers add up to 90% of the problem, I don't blame layers in general. If you remove the parts that legitimately are just bad by themselves, you solve most of the problems.

If you have a dozen layers and they each add 5% slowdown, okay that makes a CPU half as fast. That amount of slowdown is nothing for UI responsiveness. A modern core clocked at 300MHz would blow the pants off the 600MHz core that's responding instantly in the video, and then it would clock 10x higher when you turn off the artificial limiter. Those slight slowdowns of layered abstractions are not the real problem.

(Edit: And note that's not for a dozen layers total but for a dozen additional layers on top of what the NT code had.)

Unfortunately, at this point some of the slow layers are in hardware, or immediately adjacent to it. For example, AFAIR[0], the time between your keyboard registering a press, and the corresponding event reaching the application, is already counted in milliseconds and can become perceptible. Even assuming the app processes it instantly, that's just half of the I/O loop. The other half, that is changing something on display, involves digging through GUI abstraction layers, compositor, possibly waiting on GPU a bit, and then... these days, displays themselves tend to introduce single-digit millisecond lags due to the time it takes to flip a pixel, and buffering added to mask it.

These are things we're unlikely to get back (and by themselves already make typical PC stacks unable to deliver smooth hand-writing experience - Microsoft Research had a good demo some time ago, showing that you need to get to single-digit milliseconds on the round-trip between touch event and display update, for it to feel like manipulating a physical thing vs. having it attached to your finger on a rubber band). Win2K on a hardware from that era is going to remain snappier than modern computers for that reason alone. But that only underscores the need to make the userspace software part leaner.

[0] - Source: I'll need to find that blog that's regularly on HN, whose author did measurements on this.

Perhaps it's this one?

http://danluu.com/input-lag/

Yes, this one exactly, thank you!

At this point there are so many layers that it would be hard to figure out the common problems without doing some serious work profiling a whole bunch of applications

"But when you add them all together, you end up with a terribly laggy affair"

I think this is the key.

People fall in love with simple systems which solves a problem. Being totally in honey moon they want to use those systems for additional use cases. So they build stuff around it, atop of it, abstract the original system to allow growth for more complexity.

Then the system becomes too complex, so people might come up with a new idea. So they create a new simple system just to fix a part of the whole stack and allow migration from the old one. The party starts all over again.

But it's like hard drive fragmentation - at some point there are so many layers that it's basically impossible to recombine layers again. Everybody fears complexity already built.

Except for when they do.

That depends how much overhead is in the VM. WASM is designed to be thin. Java is not.

And then came WASM...

WASM is designed to cut through all the bullshit and leave only a minimal amount of bullshit, even though it turns out there's still a lot of bullshit in the other parts of the system that WASM doesn't address.

I like websockets for the same reason. Each message has a two byte overhead compared to TCP. Two bytes. Unfortunately messages sent by the client have a whopping four additional bytes to help protect buggy middleboxes.

Well, the way in which we got there is in adding more features to the "obvious" answer: all any given site necessarily has to do, to have the same presentation as today, is place pixels on the screen, change the pixels when the user clicks or types things, and persist data somewhere as the user does things.

Except...there's no model of precisely how text is handled or how to re-encode it for e.g. screen reading...the development model lacks the abstraction to do layout...and so on. So we added a longer pipeline with more things to configure, over and over.

But - the computing environment is also different now. We can say, "aha, but OCR exists, GPT exists" and pursue a completely different way of presenting many of those features, where you leverage a higher grade of computing power to make the architectural line between the presentation layer and the database extremely short and weighted towards "user in control of their data and presentation". That still takes engineering and design, but the order of magnitude goes down, allowing complexity to bottleneck elsewhere.

That's the kind of conceptual leap computing has made a few times over history - at first the idea of having the computer itself compile your program from a textual form to machine instructions ("auto-coding") was novel and complex. Nowadays we expect our compilers to make coffee for us.

Here's a fun fact, most fonts have a font program written in a font specific instruction set that requires a virtual machine to run. There is no escaping the VMs!

A VM is not a VM. Just because a program’s semantics are defined in-terms of “a” virtual-machine (Java, .NET, etc) - it’s otherwise entirely unrelated to virtualisation.

It always kind of cracks me up when I hear someone having to explain the difference between between these 2 breeds of VM.

At one point back in school a friend said to me "hey, I can't figure out how to install and boot JVM on Virtual Box. I need to use it for homework in another class. Help me?"

I wish I had been able to explain it as succinctly as you. Instead I sat there laughing in the guy's face for a good minute, eventually realizing from his expression that he was being serious, which only made me laugh even harder.

> But I really wonder - what would be more complex?

> Building interactive programs based on HTML or Logo (if anybody does remember)?

Hold my beer: my Github Actions CI scripts use Logo to generate the bash build scripts as images that are then OCRed and executed by a special terminal that exploits the Turing complete nature of Typescript's type system.

Turtles all the way down!

>If you can't load a page with 30 dishes fast enough, you have a serious problem

That depends on your scale. If your product is "large enough" it is relatively easy to get into the range of several seconds of response time.

Here are some of the steps you may want to execute before responding a resquest to your user:

- Get all the dishes that have the filters the user selected

- Remove all dishes from restaurants that doen't delivery in the user location

- Remove all dishes from restaurants that aren't open right now

- Get all discount campaigns for the user and apply its effects for every dish

- Reorder the dish list based on the history of the user interactions

Now imagine that for every step in this list you have, at least, a single team of developers. Add some legacy requirements and a little bit of tech debt... That's it, now you have the perfect stage for a request that takes 5-10 seconds.

Dafuq kind of scale could even a service for lots of restaurants have, that that wouldn't be a single query taking milliseconds to execute? I'd maybe split the last bit (user history re-ordering) into another operation, but the rest, nah, not seeing it, one quick query, probably behind a view.

I mean maybe your DB is a single node running on a potato and your load's very high but you're also somehow never hitting cache, but otherwise... no, there's no good reason for that to be slow.

[EDIT] Your last paragraph is the reason, though: it's made extremely poorly. That'll do it.

Recently I stumbled across the online catalog for Segor Electronics (segor.de I think? Google it. Only in German. They're not paying me to post this)

It's extremely fast. Super duper fast. And a quick look at the network debugging tab shows why: it loads the shop's entire catalog data (about 3 megs) upfront, and the entire application runs locally with not a single request until you buy something. Now that's efficiency.

Really. Go to their website, clock on KATALOG and click some random buttons, pick a product at random, add it to your cart, remove it from your cart.

The product images are the only things that aren't pre-loaded.

None of the things you said mentioned should be hard. We did complicated things like that and more in the 1990s.

But it was different...

Yeah. It was. That's exactly my point.

A major problem is the number of places in our code stacks where developers think it's perfectly normal for things to take 50ms or 500ms that aren't. I am not a performance maniac but I'm always keeping a mental budget in my head for how long things should take, and if something that should be 50us takes 50ms I generally at some point dig in and figure out why. If you don't even realize that something should be snappy you'll never dig into why your accidentally quadratic code is as slow as it is.

Another one I think is ever-increasingly to blame is the much celebrated PHP-esque "fully isolated page", where a given request is generated and then everything is thrown away. It was always a performance disaster, but when you go from 1 request to dozens for the simplest page render it becomes extra catastrophic. A lot of my web sites are a lot faster than my fellow developers expect simply because I reject that as a model for page generation. Things are a lot faster if you're only serving what was actually requested and not starting everything up from scratch.

Relatedly, developers really underestimate precomputation, which is very relevant to your point. Your hypothetical page layout is slow because you waited until the user actually clicked "menu" to start generating all that. Why did you do that? You should have computed that all at login time and have it stored right at your fingertips, because it is a reasonable assumption given the sort of page you're talking about that if the user logged in, they are there to make an order, not to look at their credit card settings. Even if it expensive for reasons out of your control (location API, for instance) if you already did the work you can serve the user instantly.

Having precomputed all this data, you might as well shove it all down to the client and let them manipulate it there with zero further network requests. A menu is a trivial amount of information.

It isn't even like precomputation is hard. It's the same code, just running at a different time.

"But what about when that doesn't work?" Well, you do something else. You've got a huge list of options. I haven't even scratched the surface. This isn't a treatise on how to speed up every conceivable website, this is a cri de coeur to stop making excuses for not even trying, and just try a little.

And it is SO MUCH FUN. Those of you who don't try you have no idea what you are missing out on. It is completely normal on a code base no one has ever profiled before to find a 50ms process and improve it to 50us with just a handful of lines tweaked. It is completely normal to examine a DB query taking 3 seconds and find that with a single ALTER TABLE ADD INDEX cut that down to 2us. This is the most fun I have at work. Give it a try. It's addictive!

Yeah, your last point is totally spot on, it is so gratifying to make something feel obviously much faster, in a way that few other things in programming are, and there's usually a lot of low hanging fruit.

Also, if you work on a website, the Google crawler seems to allocate a certain amount of wall time (not just CPU time) to crawling your page. If you can get your pages to respond extremely quickly, more of your pages will be indexed, and you're going to match for more keywords. So if for some reason people aren't convinced that speed is an important feature for users wanting to use your site, maybe SEO benefits will help make the case.

ALTER TABLE ADD INDEX, in some cases, can create speed increases in multiple orders of magnitude.

I was using a SAST program that used MS SQL Server and was generating reports, and often finding the reports took HOURS to generate, even when the report was only ~50 pages. A report on one specific project took over a DAY to generate a report. I thought it was ludicrous, so I logged onto the SQL server to investigate and found that one query was taking 99% of the time. This query was searching through a table with tens of millions of rows, but not indexed on the specific rows it was checking against, and many variations of the query were being used to generate the report. I added the index (Only took about an hour, IIRC), and what took hours now took a couple minutes.

I was always surprised the software didn't create that index to begin with.

Because it can hog a lot of disk space and slow inserts

Somehow missed this reply for 3 days...

In my use case, impact on inserts was not noticed. I did notice higher disk space usage, but it absolutely was worth it. Spending $200 on a larger disk was absolutely worth saving literally days on report generation.

I'm a well constructed system, you could probably get this down to one PostGIS query with some joins and spacial indexes that should run in <100ms.

If you think that’s enraging just wait until you get a page that unloads the previous content as you scroll. You can only search the text that’s visible. Maddening.

And when you're about to click on something, something new loads and everything jumps unpredictably and you end up accidentally clicking on the wrong thing lol

This is honestly the worst part of it to me. It happens quite a lot!

Yes, in Windows 50% of my day is fighting with something obscuring my view or taking focus. Something pops up just as I was clicking or pressing Enter. I have to sign into multiple systems in the morning and sometimes it takes four attempts to enter creds for one login because I keep getting interrupted. It's infuriating.

you would think they could figured out that programs not directly opened by the user shouldn't be able to steal focus from the program the user is currently interacting with. seems like basic UX/UI failure

You're talking about people who haven't figured out you should be able to edit the options on the right click menu from a single settings menu and that the task bar should expand and contract dynamically with the number of open windows. Microsoft stopped improving the Windows UI around 2006.

You’re talking about people who use Macs.

desktop user interfaces on all 3 main operating systems peaked by 2010, at that point everything became aimed at clueless cellphone users.

This is actually pretty hard to get right. Just yesterday I was confused why opening my text editor under KDE didn't pop up a window. Turns out some update to KDE's focus stealing prevention (or some other involved component) changed things so the new text editor window got pushed behind existing windows.

This isn't an argument for not trying though.

Stealing focus should be a misdemeanor!

jfyi this is not new - we confronted this in 1996 when the web was very young.

Even more annoying is when ads pop in a second or so later under the cursor position just before you click, taking you to the ad not what you wanted to click.

Ads? I have a solution for ads... ever heard of uBlock Origin? :)

I am using uBlock origin, Privacy Badger as well as a PiHole for my personal use.

That's not always an option for a given work environment, however.

I could kind of understand things moving around back in the 2000s when we were all getting used to AJAX but all these years later can we (at least) have the main navigation links stay still?

This is so frustrating. Though I recently come across a rare bread, that I thought stood out on load speed. The BBC of all places. While following the sub disaster I was pleasantly surprised at how quick it always loaded. Nearly always it would load near instant after clicking my bookmark. (Definitely not something that is that common when you live in NZ)

Not at all what I expected from a news site. They're usually full of crap and dog slow.

This is the specific URL I experienced this with. Though the whole site seems mostly very quick. https://www.bbc.com/news/live/world-us-canada-65967464

And this is on a 2017 MBP, which some sites are really slow. Nothing crazy like the new silicon CPUs here either.

It’s fast but it still resets the scroll to the top about 700ms after it loads on an iPhone

If you can install Lagrange on Mac, install it and try gemini://gemi.dev

Then head to the Newswaffle link and input https://bbc.com or just scroll down the page to head to the converted site.

Sorry I forgot the URL:

https://gmi.skyjake.fi/lagrange/

Adjacent but similar, I am so over all of the animations and corporate bullshit on pages. I run a business making decent and super optimized web pages and people love them. They’re the only website in their town and field that doesn’t take 10 seconds to load and render.

Can you link to your website?

Unfortunately I don’t have a website for myself and I don’t feel comfortable sharing my client’s websites. I operate purely through word of mouth in my local town, and I don’t have any aspirations to “go big”

I realize I didn't formulate my comment well -- the XYZ problem happened.

I am interested in your fast loading techniques in general. I also am considering making a bunch of personal / pro websites where I'll use a static generator. Just looking for some inspiration and ideas to steal I suppose.

Since it's kinda fresh pursuit for me, I am still looking to gather some links and do proper research. I wasn't looking to deanonymize you, my apologies.

Oh sure, no worries!

As far as my inspiration, I use Craigslist and google as my inspiration. I try to get a sleek and simple look like google pages, but maintain the “old school” functionality and layout ideas of Craigslist .

As far as actual development is concerned, I use oracle ARM servers that are grossly overpowered for a webhost, cloudflare nameservers OR CDN, and I keep as much of the development as possible server side with as little JavaScript as I can. An example was a simple blogging system I made. The entire system is set up with a MariaDB table that has “title, date, image url, and content” as the data bits for it, and then each function works on one of two pages: a backend using php session that has all of the functions with get request, and a front end that has all of its content on a page with post requests. There is no JavaScript involved on either page, which means the stuff transmitted over the internet is lesser, the stuff done on the client computer is lesser, and the number of outside calls is lesser. This does make it “less responsive”, but does the blog really need image zoom in on hover and shit like that?

I have found the best way to develop for speed and simplicity is to curb the enthusiasm of the client from “looks as good as possible” to “simple, cheap, fast, and robust, while still looking better than average”

The final suggestion I have is to develop with security AND accessibility in mind first. If you want to put aria links of all of your stuff, it is much harder to go back later and 1) determine what the link does, and 2) write an aria for it than it is to just include it in the first place. Always follow proper form for mitigating risks like SQL injection and XSS, and do as much as possible on the server before you resort to JS.

If you are looking for a couple of sites that I didn’t build, but get the point of what I am trying to do across, check out

Smashingmagazine.com Hacker news doesn’t look the best, but it follows the logic set forth, Openai.com (this one surprised me because if you remove a lot of the slightly more interactive elements it is fast as hell)

If you have any specific questions, ask away and I’ll do my best

Google specifically reengineered YT last year to do exactly that! From loading ready to display html with subsequent clicks ajaxing more html to loading 1MB .js library and 400KB of json on first load with every subsequent click requesting anotehr ~400KB of json to be interpreted.

This is called cumulative layout shift (CLS for short) and there’s a push in web dev to work against and around this - it’s recently become part of the performance measurement of googles lighthouse scoring and server side rendering and static site generation metaframeworks like nextjs and Astro allow you to send out the entire static page HTML without having to lazy load any new data.

We also have tech companies that claims sub 300ms request response time is good enough. I wish people look at StackOverflow and understand how they do everything at under 20ms.

As a person from New Zealand I am accustomed to every single request taking a minimum of 300ms RTT and sometimes it's shocking when it doesn't.

Unfortunately for most users of most software, "losing interest" isn't really an option - they need it to do some job or other.

I get your point, but "losing interest" can also mean losing flow, because the user got interrupted for five seconds instead of instantly taking the next action in their mental plan.

When apps have these kinds of interruptions all over the place, that's even worse than just having them at startup.

I was just reading this week about someone trying to get their UHK keyboard to launch an application on Windows by producing a sequence of keys starting with the Windows key. They needed to put in a delay to get this to work, and it reminded me of my frustrations launching programs in Windows as the start menu takes its sweet and variable time. Not least because I know the technology has been focused on getting adverts into the start menu.

Isn't there still the Run dialog, Win+R in newer versions of Windows?

this is the way.

but putting delay between events (not keystrokes) is nevertheless a good practice

Thanks. I had forgot about that because the Windows key by itself was fast enough in Windows 7 that I stopped using Win+R.

There is, but even that's not perfect. I have this stupid habit where I bring up the NVDA screen reader when I want it by typing Windows+R, typing "nvda", and pressing Enter. (I have low vision, and I use a screen reader sometimes, but not all the time.) I know, I really should use a desktop keyboard shortcut instead. Anyway, it's muscle memory, and I do it automatically, without watching for the Run dialog to appear. Only sometimes, the Run dialog doesn't appear fast enough, and maybe the "n" doesn't make it into that dialog's edit box. Or, on one or two embarrasing occasions, the Run dialog didn't grab focus at all, or at least not until way too late, and a message that just said "nvda" made it into a chat window.

MacOS manages to provide an advanced search launcher experience as fast or faster than the run dialog that requires the perfect exe name.

What’s Microsoft’s excuse? Tired of their incompetence being handwaved and a several decades old jank non-solution being held up as acceptable. MS needs more accountability in their teams.

Or this new version will just break... I had some nice weeks when the search just didn't work at all... While I was too lazy to restart the computer to fix it...

Then again, I guess any other OS might break in same way. Like my Debian VM just kinda stops responding to part of the screen sometimes if programs are maximised...

This is partly an OS design issue. There's no deep reason the OS should ever throw away keypresses, but contemporary GUIs have a very weak and flaky notion of focus. Contrast this with mainframe apps where users could learn to go incredibly fast, because keystrokes were buffered per connection and the mainframe would process them serially, so even if you typed faster than the machine could process them it wouldn't matter, no keys were lost.

It's not necessarily Windows throwing away keypress events but the order of events system wide not necessarily staying in the expected order or the target for an event not being active at the right time.

If you activate the start menu with a keypress it's going to grab focus. Before it grabs focus the previous window in focus will get events. The same applies with panels (drawers? I forget Windows' name for them) in the Start Menu. There's a non-zero time between activation and grabbing focus to receive keypress events.

Everything from animation delays to stupid enumeration bugs can affect a windows not grabbing focus to receive keypress events. Scripting a UI always has challenges with timing like this.

A mainframe terminal has a single input context. You can fire off a bunch of events quickly because there's no real opportunity for another process (on that terminal) to grab focus and receive those events.

Note the above doesn't absolve Windows of any stupid performance/UX problems with bad animation timings and general shittiness. Microsoft has been focusing on delivering ads and returning telemetry with Windows instead of fixing UX and performance issues.

Yes, my point is that an alternative OS design could serialize keystrokes such that a keypress has to be handled (including focus changes) before the next keys are delivered, allowing you to type ahead without keypresses going to the wrong place or depending on the vagaries of timing. It might require a different approach to UI API and design, though.

That alternative OS is called... 16-bit Windows.

That's not really practical with a preemptive multitasking OS. There's no guarantee (without real-time scheduling) any process will have uninterrupted time on the CPU(s).

According to an external wall clock the keypress events happen at seconds 1, 2, and 3. The first press triggers a window to appear (menu panels are a type of window). It takes 0.5s to instantiate and register to receive keypress events from the shell. Wall clock time is 1.5s. Nice.

The second window (menu panel) receives a keypress event at wall clock 2s which opens a third panel. That panel because it has more complicated drawing and page faulted so had to fetch a page from disk swap unfortunately took 1.2s to register for focus. A keypress triggered at wall clock time of 3s. Our third panel though didn't register focus until wall clock 3.2s. That keypress went to panel 2 because that had focus when the keypress event triggered. All times greatly exaggerated.

The shell needs to add events to processes' event queues but it can't just arbitrarily add them to every process. It also can't know any individual window wants events until the process tells it so. Unlike mouse events a keypress event doesn't have coordinates so a process can't really figure out the intended target of an event.

A model that prevents preemption means your back to the Win16 cooperative multitasking. A process can't be interrupted until it gives up the CPU willingly. That however means background processes can't do work while a foreground process holds the CPU. If you make just your shell and GUI apps cooperative the responsiveness of the system will end up awful.

That's the issue you'd face with today's operating systems and UI designs, yes, but I'm talking about a hypothetical new OS design.

In such an OS the APIs would allow you to atomically transfer focus as part of other operations, for example, starting a new program or opening a new window could simply transfer focus atomically to the pending new program/window such that the OS buffers keystrokes until the recipient is ready to receive them. Also, taking focus would require you to advertise what keys you're willing to receive, allowing a focus cascade such that there's never any situation in which keystrokes get delivered to a UI that isn't able to do anything with them. At the top level of the shell there'd be a kind of global command line or palette that is the default receiver of all other unhandled keystrokes. Because focus transfer is always deterministic under this scheme, people can learn where keystrokes will go without timing playing a part.

Mainframes don't buffer keystrokes at all: rather, they send a screen to the terminal with marked "fields", and then the terminal handles all keystrokes until you press return or one of the attention keys to submit the changes back to the mainframe. Thus, even on a heavily loaded system, typing is instant because the main CPU doesn't get involved at all

Right, but what I mean is, if you press some keys to move from one screen to another, you can start typing before the navigation is complete and those keystrokes will be buffered by the terminal. They won't just be discarded, meaning you can learn to type ahead of where the server is up to.

That sounds terrible. Why interact with the start menu at all if you can just start the application itself through the path? That's the kind of abuse that delays things in the first place.

OTOH I recall alt-tabbing full screen games (Warcraft 3 on a single core machine is a specific memory) and then sitting back for a while…

Office suites have never been good, but office suites in like 2005 seemed to stretch systems to the breaking point.

Lots of consumer software has always sucked out of the box, I guess if you are here you were possibly a technically savvy kid at some point, is it possible that you were just more selective about the types of programs you ran when you were using the computer for fun?

Old text word processors on my 286/386 back in the late 80s / early 90s, ran just fine. Instant everything. Only thing that was truly slow was the scanner.

WordPerfect 5.1 for DOS has entered the chat.

I have fond memories of that, but basically the editor was a UI into a linked list with a blue screen. So not comparable to what people are being asked to do with Word and 365 today.

My personal beef with Word is that it struggles so much with long documents. Trying to read, say, a 300 page spec from 3GPP is miserable.

Most games don't need to change screen resolutions anymore which is the expensive bit since not only do you have to wait for the hardware to settle, you have to throw out basically everything in GPU memory and reset it all

Also, having to throw out basically everything in GPU memory is largely a thing of the past in the first place.

I still have this instinctual reluctance to change screen resolution in a game's setting screen, even though 99% of the time it's an instantaneous thing these days.

Modern games typically don't change the screen resolution at all. If there is a resolution setting then it usually is just for the internal render resolution and the final pass will scale that up to the native resolution of the display. Changing the screen resolution only made sense with CRTs where the display is actually capable of different resolutions unlike LCD displays where there is only one native resolution and non-native resolution needs to be resampled (either by the display, the GPU or the game).

> you have to throw out basically everything in GPU memory and reset it all

This is not an inherent limitation of CPUs but a part of Windows' exclusive fullscreen concept. Just another thing that was simply accepted as the way things are instead of being improved (until exclusive fullscreen went out of style).

Back then you ran games in proper fullscreen mode, whereas nowadays you run them in windowed mode (even when it's called fullscreen windowed).

If you get bad performance in a game nowadays it's a good idea to try proper fullscreen. Alt tabbing might be slow, but the game will run better.

Full-screen games were a specific issue because they would have full control of the graphics card (GPU multitasking hadn't been invented yet or something). When the game gets focus it has to set up the GPU from scratch.

This is what happens when you have a leaning tower of abstractions, with each layer being developed with a philosophy of, "it's good enough". Some performance loss is unavoidable when you're adding layers, but that aforementioned attitude of indifference has a multiplicative effect which dramatically increases losses. By the time you get to the endpoint, the losses snowball into something rather ridiculous.

Along those lines, I have numerous clients who just want plain Ruby on Rails -- no react front end. They are all business to business, or at least professional users on the end. They just want their data loaded and to work with it.

Ruby on Rails may not be the poster child for speediness as things get big or complex, but if you aren't fighting the ORM, it's consistently quick from click to data.

Also, RoR is definitely not dead.

Ruby on Rails is plenty fast, especially with Turbo. The biggest RoR speed drop is n+1 queries imo.

Which is not a RoR issue. You get those accidentally if you write plain SQL as well. (Actually passing the AR query fragments makes the n+1 easier to avoid in complex situations)

Each level of abstraction has its own caching and buffering routines because the underlying layers are slow, and without the ability to make them better, you can only put your own cache on top of it. This helps initially, but in the end, the time goes wasted managing all those caches and buffers at every given layer.

Recently I re-discovered my old collection of mp3s. I copied them to my laptop and started listening (using VLC). It blew me away how pleasant the experience was, particularly the overall responsiveness, navigating from track-to-track, skipping around in a track, stuff like that. I never really noticed the delays from streaming services until they were gone.

Spotify’s trick when it first launched is that search and playback was so fast it almost felt like you had all the music in the world on your hard drive.

Unfortunately I cannot think of a single thing that has gotten better about Spotify since I started using it, and a lot which has gotten worse.

Depending on when you started using Spotify, accessibility might have gotten infinitely better. The original Windows app, with its custom GUI toolkit, was completely inaccessible with a screen reader. Then they re-did the UI using Chromium Embedded Framework.

The first step to solve a problem is to measure it. Do you know of a windows program that can measure the latency of the UI of other windows apps ?

What really drives me mad is the latency of some file selection dialogs for example which can take like 10 seconds.

> What really drives me mad is the latency of some file selection dialogs for example which can take like 10 seconds.

That's why the obfuscated it and now it takes 30 seconds. (Win 10). Unless you want to save on OneDrive.

You can get lots of good information from ETW https://learn.microsoft.com/en-us/windows-hardware/drivers/d...

There's also Dtrace https://learn.microsoft.com/en-us/windows-hardware/drivers/d...

Some file selection dialog (and explorer) issues come down to the anti-virus. I've had folders on an SSD that took a minute (60 seconds!) to load. After I added it to an exclusion list in Defender it loaded in a second.

Another one that can be slow with file dialogs is that sometimes (maybe it has been fixed now) it will try to query whether a networked drive is around on another computer. If it isn't then the call to it can be blocking your file UI.

A third problem I've noticed with file selection dialogs and explorer is that the My Computer 'folder' that contains your disks takes a long time to load. Much longer than any sub-folders on any of the drives.

I think the problem is largely with explorer.exe. If I browse those folders in a web browser the experience is snappy.

Trying to meet a specific threshold is part of the problem. The better the development hardware, the earlier that threshold is met in testing, which tends to mean optimization effort falls off a cliff.

Also that threshold is an entire 400ms. We should expect significantly better than that these days.

About 20 years ago I was evaluating solutions for reporting to see if we could save money switching from Crystal Reports. One reason we stayed with Crystal was they did something they other report engines did not; they made available for display every page as it was rendered. So for a 400 page report, you could start working with it immediately. It took each engine (with a couple exceptions) about the same time to generate the entire report, but for the other engines, you had to wait until they were done.

There is speed, then there is the perception of speed. Crystal got this right.

People got too used to the Web - slowly loading stuff - and so began to tolerate native apps also loading slow.

And they got too used to receiving updates over the internet (as opposed to buying a CD-ROM), and so began to tolerate software full of bugs.

This cuts both ways

Because the user would rather wait a minute to load Photoshop, than have MS Paint that loads instantly.

Note that modern versions of MS Paint (with few improvements over the original) takes seconds to load on a quad core 3+ghz machine, loaded from an SSD.

Is this just the C# runtime being slow or just lots of abstraction?

I would not say that the C# runtime is slow, but it is a JIT compiler that is not optimizing for start-up (as far as I know), and it is "doing a lot of work" at runtime to achieve the eventual performance it is capable of. Start-up time is not the most important property for a lot of services, but for user applications it's pretty high up there, so if the underlying runtime is not optimizing for that this shows a disconnect in the choice of technology stack.

I'm quite impressed of both .NET and OpenJDK in some metrics, but it is often not resource efficient, which is something I do value.

One example of an application that works as I would expect others to do is MuPDF, Being able to open 20MB+ PDFs in 1/10 seconds on a 10 years+ old laptop.

By the way, does anyone know why Debian launches LibreOffice so much quicker than Ubuntu, Fedora or Archlinux (or any other distro I've tested with)? In Debian its 1-2 seconds, and the others 5-10 seconds. I mean it could be included extensions or how they are configured, but I'm honestly interested.

Maybe you're using the older Java based libreoffice on the other machines? It was mostly rewritten in C++.

That's pretty odd to assume. All but Debian are running more or less the latest, and Arch is on the "fresh" track.

Did not assume. Asked, maybe the other distros are old versions. Not sure why else there would be a huge difference... maybe flatpack/snap dependencies not in fs page cache.

Ok, sorry for assuming your intent. No, its nothing like that. They are all the distro provided stable versions installed as "regular" applications.

And it seem to be the start up process that differs, as putting them all in a ram-disk does not alleviate the issue, and restarting the app cuts the time in ~1/2 but equally for each distro.

My guess, as I said first is what default libraries as loaded, and possibly how they are configured. I do however find it strange that this has not been mentioned elsewhere as I've been struck bu this difference for years, when I happen to load a pure Debian install (not what I usually use).

I keep harping on Visual Studio, but I learned programming with Borland Turbo Pascal (and later Turbo C/C++) on a 4.77MHz machine with 512k memory. It was orders of magnitude more responsive than VS on my current 16 core 3.5GHz 128GB machine.

The only exceptions are: 1) the actual build, which is faster on the modern machine, but only for a large number of source files and 2) reading and writing files - a floppy disk cannot beat an nvme drive of course.

It was also doing about 3 magnitudes less work

What is this supposed to mean?

Reminds me of my hp48 calc, which original system was often .. sluggish, but with enough input buffer and predictability (stack + RPL) meant that it was actually beneficial since it forced you to learn things by heart and anticipate more, and the pauses would serve as thinking time for your brain. A rare kind of slow and laggy turning out to be fun.

Also impressive how our brain is sensitive to all of this.. no matter how impressive a current OS / web browser / jitted js is.. I dearly miss the past eras "behavior".

We're so glued to our screens now that our threshold for losing interest is far higher. We'll check our phone while waiting for a desktop app to open rather than walking away and finding another activity.

The one I can’t stand is keyboard input lag when a paragraph gets large. Happens in seemingly every app except vim.

I’ve been sharing videos like this for a month or two

I have a 2015 MacBook Air I abandoned recently for being so painfully slow to use that I had almost not touched it for months. I have an iPad Air 2 that is basically unusable at this point. Both are 2-3 orders of magnitudes faster than those old computers that work instantly.

But windows and web apps are super slow now too

Think of all the landfills and wasted work hours earning the money needed to fill those landfills. The heavy and rare metals

This is proof that if computers were 10x faster, they would run slower than ours today, because in the past we’ve seen that be true over and over. The software companies will just make heavier and heavier programs and operating systems until we have gained nothing but a significant amount of co2 emissions

Aren't those devices also running non-contemporary OSs? I wonder if installing the factory OS would make them seem fast again, albeit at the cost of 8 years of software updates.

This is only true as the software industry keeps piling abstractions on top of abstractions, as Moore’s law allows it. But we’re reaching the end of the Moore and already feeling the effects of it, for example Javascript frameworks priding themselves on performance instead of features.

Give it some time for the industry to finally mature.

> What makes it even worse is how unpredictable the lags are so you can't even train yourself around it.

What is worse than that: not being able to predict if inputs will be buffered or dropped during unresponsiveness. I kind of look like an idiot when I keep clicking/typing away on someone else’s computer while things are frozen, thinking “oh, it’ll catch up in a bit”, and then 5 seconds later I have to work harder to fix the chaos: some keystrokes at the beginning made it through, then only every other one, then the next couple hundred got dropped, but the next 100 came through fine, and interspersed everywhere there are bizarre runs of duplicated keys, as if I had held the letter aaaaaaaaaaaaaa down continuously.

Everyone’s mix of hardware, OS, text editor, text editor plugins, etc makes this behavior highly variable, and hard to guess if it makes sense to keep typing or just wait out the frequent 1-5 second lockups.

Android is almost as responsive as things like that. Linux is good, sometimes, windows seems better.

1GB programs are rarely instant but that's usually just the price for very complex functionality if it's too interconnected to load parts of it on demand.

Some additional things to note:

Windows NT 3.51 minimum hardware requirements were a i386 or i486 processor at 25MHz or better and 12MB of RAM for the workstation version. So the 600MHz machine with 128MB RAM is exceeding the minimum requirement by (conservatively) 24x in CPU speed and 10x in RAM, along with all the architectural improvements from going from the i386 to what's presumably a Pentium III-class machine.

If that's actually a Surface Go 2 running Windows 11 - well, it doesn't have a quad-core i5 as the tweet claims - the Surface Go 2 came with a Pentium Gold or a Core m3; both with only two cores and of those is an ultra-low power variant.

As such, that exactly meets the minimum CPU specification for Windows 11 and only doubles the minimum 4GB RAM requirement.

I'm not trying to apologize for the difference here, but it's not an entirely like-for-like comparison.

If you ran Windows NT on the bare minimum it was not as slow (barring hitting swap) as Windows 11 on the bare minimum hardware. Not even close. Windows NT on the minimum hardware wasn't a joy exactly but it was certainly workable. If you run Win11 on the bare minimum you'll very quickly learn to hate everything.

Are you sure this applies to laptops from back then? The minimal laptop that could run NT must have been so much worse than a desktop.

The min specs would be the same, laptop or desktop. A laptop with those kind of specs back then probably just had terrible battery life and was really big & heavy, didn't throttle down or anything. Not like today when you'd expect the "same part" or "same clock speed" to not really be the same, between a mobile and desktop chip.

IIRC laptops of that sort of era often used slower RAM, and laptop hard drives were generally _much_ slower than desktop ones.

(Also there was a period when a lot of laptops used non-Intel x86 implementations, which typically weren't very good. Cyrix, Via et al.)

In 1998, I exclusively used NT 4 on a Dell Latitude to do software development for a month while working overseas. It wasn’t super fast but it was comparable to a non-workstation desktop - in both cases you could not skimp on RAM but otherwise it was fine. The biggest gripe I had was the Synaptics touchpad, which is evergreen.

They do have a better example with Windows 2000 on the Pentium 3 which is very era appropriate.

I see similar sluggishness opening command prompt on my Ryzen 3700X with 64GB RAM on Windows 11 22H2 with an NVME SSD. First it draws the outline of the window then fills it in with content. And that's repeatable!

I feel like the intent was to say notepad from 20 years ago and notepad from today has (approx) the same functionality whereas the processors are x4 times faster, it should be at least as fast as it was before, shouldn't it? In my mind, regardless of the OS requirements, a processor x4 more powerful shouldn't need double the time to launch the same program unless you've added x4+ features.

I can start notepad on my relatively slow Win10 VM with spinning disks in RAID and it starts with similar speeds - starting it on my physical windows machine with a SSD, it launches at exactly the same speed.

Another very similar example to this is the adding text feature in MS Paint. I noticed that somehow on the Windows 11 version, it takes many seconds after clicking the "add text" button to be able to actually start typing. Previously, it was instantaneous.

Notepad back then could only edit 32kB maximum files, even on 32bit NT, it was literally all the text widget could handle.

So no, it's not really fair to compare a 'simple' text editor.

It is a fair comparison.

If you edit the same 1KB file on each computer side by side the 30 year old computer will be more responsive than the modern one.

That's what people are taking issue with.

Heh, I've not any one talk about AV and things like the smart screen filter.

A huge number of security related things are going on.

Also windows logs a ton of telemetry these days.

I think the stock Notepad in Windows 10 is perfectly fine and speedy at least, I've never considered it too slow unless I open a huge file with word wrapping on.

Notepad2 is my all-time favorite though. It supports key features like line numbers and directionless search, but is much closer to stock than Notepad++. [0]

[0] https://www.flos-freeware.ch/notepad2.html

64KB.

Notepad on NT4 could edit files as large as you had memory. I never used 3.5 but I guess they must have made that change in NT4.

I imagine they're also not using vintage hard drives. Its pretty common in the retro computer world to use things like CF and SD cards for storage emulation. Even a basic CF card is miles faster than a 1990's HDD. Put in a period-accurate storage device and see how bog slow it gets.

You might try reading the second line of the Tweet before criticising its author.

The text content of the tweets seem pretty unreliable as this states its a Surface Go 2 with a Quad Core i5, despite the fact the Surface Go 2 never shipped with anything quad core and definitely not an i5.

Maybe it is a spinning rust disk. Even then there's a world of difference between a period accurate drive and a late model IDE drive. The last IDE drives had more drive cache than most desktops had RAM when NT was new.

Why is Win11 so slow and unoptimized that it needs such crazy hardware.

I don't think it's unoptimized as much as it's extremely bloated.

What's the difference?

Bloat is intentional and fills Microsoft’s wallet.

Optimization drains Microsoft’s wallet.

"Bloat" includes the addition of intentional, but frivolous, features. An application can be well-optimized but still slow simply because it's doing too much.

But I think the reason that most modern software performs badly is because of optimization: we're optimizing to reduce production costs over increasing performance.

It's economic in nature. We minimize production costs by using frameworks and other labor-saving tools. The code produced using these tools tends to be poor, but hardware is cheap enough to make up for poorly performing software.

It's an intentional decision.

A meaningless term to deride a feature or service you don't like or use.

Some of that bloat is useful. Windows indexes files in the background, which would choke a single-core machine with HDD for sure. Thanks to that I can quickly access my files... well, so long as Windows is able to find the correct thing...

> Some of that bloat is useful

Well, all of that type of bloat is presumably useful to someone or it wouldn't have been written. That doesn't change the fact that there's a cost for including it.

> Windows indexes files in the background

But here's an example of the tradeoffs. I hate this behavior. It incurs an overhead that provides no benefit that matters to me. So, your useful feature is my useless bloat.

Everything's a tradeoff.

> But here's an example of the tradeoffs. I hate this behavior. It incurs an overhead that provides no benefit that matters to me. So, your useful feature is my useless bloat.

Turn it off then?

Yes? That doesn't affect my point about it being a kind of bloat.

Even when you turn the search indexer off, the indexer background service still seems to be doing ... stuff.

I have a Windows 10 VM I use for some testing and such, and all these background things keep using up huge mount of resources, no matter what knobs I turn and regedit levers I pull I just can't get it to stop.

For comparison, I also have a macOS VM which certainly isn't fast, but nothing like the Windows one. And the BSD and illumos VMs work basically fine (although in fairness they also don't start X11; but I do just ssh in to all of these machines and never use the GUI for anything).

But if you turn it off, you don't get the start menu indexed anymore. I don't need my files indexed, I just want my start menu shortcuts indexed. There's a few other small things that no longer work without indexing, though I forget what they are now. Everything is great, but there's actually other services that depend on search being enabled, as it tells you when you try to stop the service that is shutting down dependent service first.

Expect that the search totally sucks. Have you tried Voidtools Everything? It finds files instantly, even on filesystems with millions of files. Yes, instantly, you type a word and it's just there, no matter SSD or HDD. Windows' built in search is a complete waste of time.

It only searches the names.

The new Windows Terminal is also extremely slow for some wild reason

Launches into PoSh 7 x64 in <1s for me on Win 11.

> Some of that bloat is useful.

If bloat is useful, notepad in any form on any version of Windows is bloat by definition.

You've got CLI editors that are smaller.

A graphical user interface? Just bloat.

Ships with a TCP/IP stack by default? Just bloat.

Mouse support out of the box? Who would want that?

C64 lovers would likely agree with all of those points.

Oh but that's just Amiga envy.

And yet when I want to search in the files in a folder searching with windows search won't turn up anything, so I have to switch to the WSL and grep...

Indexing is a weird example to use considering how notoriously garbage Windows file search is.

For some reason even in fairly constrained subtrees it takes forever to find file names.

It’s also searching the contents. Try turning that setting off.

> Windows indexes files in the background, which would choke a single-core machine with HDD for sure.

This was done also in Win 7. It didn't have such a performance hit, but it was the first thing to be disabled after installing windows.

Windows has been indexing files for over 20 years.

Back then I would turn it off as I didn't find the search function that usable, and more than once I've had a "clean and build" process fail because some file was open and being indexed, and since Windows locks files on read, the build could not delete the file and just aborted. So, I turned it off.

And then 'everything' search tool came with instant fuzzy find. A strange experience after years of buggy and slow MS indexation.

I feel like this is something where determinism would be a win. Maybe have indexing, but pre-prioritize certain common searches.

I notice that I get completely different results on my home and work machines doing the "start button, type" search. for "Downloads", expecting C:\Users\Username\Downloads, the home machine figures it out after three characters. The work machine seems to have decided that I clearly want "File Explorer, not any particular directory" and "Change how I download updates in spite of it being a corporate-managed box where I probably can't push that button without asking IT to remote in and do so" are what I want, even when I spot it the whole directory name.

On Linux machine I can access and find my files fast. And without any indexing running on the background. Shit... even I could run the OS from a rust HDD and be usable without pain. Windows10/11 without an SSD it's painful slow.

Index for what? The Windows search has always been unbelievably bad and it has only gotten worse since Windows 7.

The term bloat (as it applies to software) is rooted in gamer-think that has no basis in reality and sends a strong signal of lack of understanding. It's reminiscent of the days of 'BlackViper' and disabling Windows Services -- again, another gamer lack of knowledge issue.

Empty notepad, just started. 82,416K working set in main memory. 25.7MB in dedicated GPU memory. 59 threads. 2 billion cycles spent since launch.

Two threads in !OpenAdatper12 spending ~1.5M cycles per second. Two threads in !recalloc spending ~256K cycles per second.

As shipped, this is no longer a single executable, it is a collection of 230 files, totaling 10.5MB, about half of which are bytewise duplicates, and another significant chunk have overlapping responsibilities, between the icon fonts and png icons.

"Software bloat is a process whereby successive versions of a computer program become perceptibly slower, use more memory, disk space or processing power, or have higher hardware requirements than the previous version, while making only dubious user-perceptible improvements or suffering from feature creep." -- https://en.wikipedia.org/wiki/Software_bloat

I'm not aware of any substantial new features. It uses a new renderer, but this does not produce a significant observable difference from the previous one beyond using more memory. It supports dark mode.

Also full unicode support on high resolution screen.

New renderer, dark mode, auto save, resume on open, HiDPI, tabs, and I'm sure a lot of things I'm forgetting.

Don't forget what Notepad.exe truly is -- a testbed for new technologies. It's not "just a text editor" to Microsoft.

I'm no gamer, and "bloat" has been a term used in the industry from well before "gamers" (in the sense used today) existed. It's been a term of art for over 30 years.

It also describes a very real thing.

While there are a lot of things that everyone would agree counts as "bloat", there are also areas of disagreement in the form of "one person's bloat is another's essential feature".

Add onto that the fact the 8th and 10th gen Intel low power mobile parts are, well, kinda garbage (low perf/watt, very little boost time, low core count) and were quickly obsoleted.

I'm not sure why Msft put that CPU and RAM combo in their own device when it's just barely past the minimum specs for Windows 10 let alone 11.

I think the bloating hardware requirements are his point. What precisely have they gotten us? Mind you, this is not the same as "what have we gotten in the time that they've bloated"!

In the tweet right below there's a video of them running Windows 2000 on the same hardware and it's just as responsive.

Yup if you run a Windows VM in a M2 Max Mac or a PC with a Intel 13900, stuff opens pretty fast too.

I'm in university and each exam I have to install windows 10 to run Safe Exam Browser (same hardware), in between I use Linux as my daily driver. The perceived difference in responsiveness is always frustrating, though I find that a lot of it probably is just due to user hostile design. No OS that constantly nags about tracking me, showing me ads, and so on will feel snappy. I'm sure there is some real lag as well though.

Microsoft has essentially turned the OS into one of those websites which show ads, news letter dialogs, cookie notices, location permission requests, notification requests and so on constantly.

does your university make you run the ["verificator"](https://github.com/SafeExamBrowser/seb-win-verificator)?

They don't

> not an entirely like-for-like comparison.

I'm not sure why Windows minimum hardware requirements are relevant at all. If they were, they could get massive performance improvements by raising the hardware requirements. "Sure it's slow, but it's running on literally 1% of minimum recommended RAM!"

They were very relevant back in the '90s. So relevant, it's why Windows 9x existed. The Windows NT 4 minimum system requirements around RAM were too high, thus deemed too expensive for consumers.

Granted, a Surface Go 2 won't win any perf competition, but even with infinite budget you still couldn't buy a desktop today that has the response times of that NT box.

I ran NT 3.51 on a PS/2 486-66 with either 40MB (maybe 48MB) RAM and a scsi disk. It was nice compiling VC++ programs on it.

I now use a Surface Go3 i3 with 8GB. It's enough for just about everything I need. Web browser, running script language web apps, Java IDE, StarCraft 2. Disabling a bunch of stuff on Win11 makes a big difference. Whenever it felt slow I looked at Task Manager CPU and googled the process name, tried disabling it and only re-enable if necessary. Oh I also have a Peltier cooler+fan that cools the back of the unit when gaming to prevent throttling.

The PS/2 NT machine was top spec at the time. The Go3 is utilitarian now though should be like a supercomputer.

There's another post with a video of how an old machine running NT 3.51 is so much faster than what we have now running on modern hardware.

[0] https://news.ycombinator.com/item?id=36503983

By that logic: Windows 10 on my Threadripper 3970x with 256G of RAM should be comparably fast to Windows NT as presented.

Since the aggregate GHz and RAM on offer is more than 25x the minimum spec for windows 10.

Win10 min spec is 1GHz w/ 2GB of RAM - my machine is more than one hundred times faster, yet, everything TFA says is true.

A lot of people are bringing up Wirth's law or other things, but I want to get more specific.

Has anyone else noticed how bad sign-on redirect flows have gotten in the past ~5 years?

It used to be you clicked sign in, and then you were redirected to a login page. Now I typically see my browser go through 4+ redirects, stuck at a white screen for 10-60 seconds.

I'm a systems C++ developer and I know nothing about webdev. Can someone _please_ fill me in on what's going on here and how every single website has this new slowness?

OMG Yes. At my megacorp I work at they have this internal HR/401k site thing. I think it goes through 30+ redirects to get anywhere. It's INSANE. We have something called "Pitstop" and clicking on the list of tickets takes 30s+ to load.

My record is Jira successfully loading a page in around 8 minutes. It seriously sat on a white screen for 8 minutes, then boom there's the page - no interaction or F5. What on earth could it have been doing for that long??

IME that's usually because:

- the database and/or the Tomcat server have way too low RAM and start swapping like no end

- way too many people had admin access in Jira and installed a metric shit ton of plugins

- the AD configuration is messed up and instead of only user accounts it loads (and verifies) tens of thousands of user and machine accounts at each login

It's probably the plugins, but even then I would have assumed that timeouts would have made it impossible to load a page that slow.

Given that people absolutely love to upload multi-GB files to Jira (and will nag the admins to disable timeouts and size limit), many admins have long since relented...

After all, why pay for an expensive DMS when you have Jira?

Jira is a horrible app though. I don't understand why it's so popular.

Worse thing is the only reason we have to use it is to log our hours. Because the CIO wanted us to be "agile". Apparently logging ones hours in Jira makes us "agile". Yeah I don't know how either. Someone ticked a nice box there for themself. Now we're just creating a useless swamp of data that has no meaning because there are no guidelines on how to log everything. Normally when you implement the full process that stuff is straightforward because you have things in other places in Jira to link to. Not in this case. The only thing we have achieved is making Atlassian a bit richer.

The same with "cloud". We had to be "on cloud". So what do they do? Migrate every physical server. Every time we need a new "server", we still have to fill in the same 18-page excel sheet. Only the tab with the physical rack location has been replaced with one with AWS locations. We still have the delay of several weeks of approvals and everything runs 24/7, nothing scales automatically or is auto provisioned. This is not "cloud". This is fooling oneself. And paying too much. We're technically in the cloud but we don't take advantage of anything it's actually good at. Paying only for resources we actually use? Nope. Auto scaling demand? Nope. Quick provisioning? Lol you wish. And we can't because the infrastructure architect team has locked everything down so nothing can be automated. They only trust themselves to that as they are the high priests.

It's really time for megacorps to stop trying to be like a startup. It doesn't work, unless you basically rebuild the entire org from the ground up. Which will never happen because it will disrupt too much. Too much legacy, too many strings attached to "the business". Too many processes that will never be changed because it means the entire org would have to change.

Just work with what you have and improve that instead of trying to pretend you're something else.

Jira redefines how slow and clunky a piece of software can be. It reliably takes 15 seconds to update an issue. Even when doing a mass update, 15 seconds per issue, the whole way.

Hell, Microsoft managed to “login loop” me multiple times on Firefox, where it ended up infinite redirects until some limit (browser?) were hit.

Commonly happens on Outlook here.

It's the SSO and the prolific usage of 3rd party auth providers. There's probably also a check in there to make sure you're not a bot.

So while all the redirects are annoying, they are probably better than all the hand rolled auth that failed in various ways.

It's SSO, which communicates via tons and tons of redirects

It's SSO, which communicates via tons and tons of redirects

Not always. AT&T goes through about 25 redirects to sign in. No SSO involved.

Are you sure?

It's SSO behind the scenes between services within ATTs environment. It's just not "SSO" to you, the end user.

That's not really an excuse - you really only need 3 page loads:

* initial page provided by the service you're logging into - this gets your email address so it can lookup your account and determine which SSO provider to redirect to

* actual login page served by your SSO provider - here you authenticate to the SSO provider. It can occasionally cause another page load to get your 2FA code if configured, or go through further identity checks

* final "page" that consumes the query parameters sent back by the SSO provider - this is often just a 302 redirect to the home page but sets a session cookie.

The main problem is that all these pages are super bloated, with tons of unnecessary JS and BS. All the code for login page that takes a username and password should be able to fit entirely on an A4 sheet of paper - it's literally just an HTML form and a few lines of CSS.

Furthermore, even beyond inter-company SSO, there are shitty companies out there which use such flows internally even though everything is part of the same security domain, hosted on the same infrastructure and thus can be hosted on the same top-level domain and use a single session cookie. Microsoft is a pretty bad one - Teams for example will use a redirect to some other Microsoft-owned domain to get your (already existing) Office 365 session; this is completely unnecessary, they can host all those things on the same top-level domain and reuse a single session cookie seamlessly.

This is the correct answer.

If anyone thinks you need more redirects than this, I'd really like to know what more you think is necessary.

Because we never decommissioned the old auth server fully and we have to serve some of the page on a separate domain. Oh and the landing page URI has changed. Also we need to send you to a certain locale. And on and on..

I never use SSO mechanisms, but I see this same problem.

The app still needs to check if your email is using SSO or is federated. And even then some apps use internal SSO to tie different systems together.

A lot of sites now don't even a "sign in" now. You only have a large "sign up" button, which you have to click, and then in very small text at the bottom of the sign up screen find the link for "already have an account?"

I haven't figured this one out either - why show the user how difficult it will be to use before they sign up? That's supposed to be for after.

Don't you see? All that matters is those tasty conversions. They want your email. They want your conversion. What's that? You've converted already and want to login? Sorry, we've got more conversions to drive, can't be bothered.

I worked with a designer that actually told me this un-sarcastically. "My KPI is signups, not logins. Bury the login link. Existing users don't move the metric."

Metrics-based and KPI-based software development has ruined quality for decades.

I've split tickets into smaller chunks because the number of tickets closed was my KPI at the time.

It's dumb and current me would just say that out loud and not participate in this circus.

Reminds me of those explorers who paid the natives for every dinosaur bone they turned in, only to be horrified when they realized the natives were breaking the bones into as many pieces as possible to collect as much currency as possible.

This is what happens when you strongly tie promotions to metrics. Make sure you have the right ones, or don't do it. Left to his own devices, the designer would probably have done the right thing. It takes a bad incentive to make someone do something like this.

"Whatever you measure will improve. This is a warning."

I wish sites only wanted email. Mostly they want to integrate with Google, Facebook and require a phone number.

I'm waiting for the day when we see an article about some government tax or bill-pay portal that only works with Facebook and Google login, no email.

If you want to even more dystopian, imagine every separate account is taxed on every forum/chat apo and failure to report is tax fraud.

There are already some essential services that use ReCaptcha and require you to be stalked by Google and be on good standing with them.

I guess you’re supposed to bookmark the deep link that goes to your dashboard then let it send you to the Interstitial login page.

Bad UX though.

Web UX designers need to find some alternative button label that users understand means both “Sign up” and “Sign in”. The site will know if your email address has an account and should then be asked does a password. Though users will still complain that the login process requires two steps: entering a username and then the backend determining whether to next serve a password or registration form.

Needing a bunch of JavaScript to make it work, which will get bungled by the devs and break it for people using password managers, making the thing even worse. Login is such a common pattern that it should be just handled by the browser.

Good point. It's unfortunate that HTTP Auth never become popular. I don't know if that was because the browser support or UX was bad or if web developers wanted more control over their sites' login flow or user information required.

https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentica...

The problem is that you have a few options:

1. send in plain text with http basic auth. Over https this isn't a problem, but https was expensive). This is sent on every request. 2. Use digest. This is also sent on every request, and also requires actual processing, at which point you might as well go for 4 so it looks nice. 3. Use certificates. Nobody does this on the pubic web. The only website I've ever used certificates was whatever certificate site predated let's encrypt, can't remember the name at the moment, and as someone who doesn't use client certificates it was a huge pain (blame that on the browsers though) 4. Use a form on the website with a session token, and you get control over the UI including error messages and styling. Much more user-friendly. You can trivially prevent the user from (easily) sending requests with pain text passwords by only showing sensitive pages like login over https. The user can't bookmark or share a URL with a password embedded in it. You can request more information than just username and password (Bank: do you want to see your checking account or savings account? Forum: go back to previous page or to homepage? SSO-ish (DayForce): what's the name of the org you're signing into?)

Congratulations, you have just designed a leak that attackers can use to determine who has signed up to your website.

Nobody wants you to ever turn a device off, or to ever log out of a website.

Guilty of implementing this exact thing only the other month.

"We" just assume that anyone who has already signed up will always be signed in.

My mother signs out of her email every time she closes it, and does the same for other websites as well. She's the only one who uses her computer, and it has a password on it (mostly because Windows won't do file sharing without one). She still refuses to stay signed in.

Not everyone wants to stay logged in, and not everyone uses a single browser; I occasionally use the wrong browser profile for something because I cbf loading up the correct one; in these cases I usually load the website in a private browsing tab to avoid container/addon settings interfering. When I can't log in easily, I get quite annoyed.

The sad part is that we have an OS-managed standard for SSO called Kerberos, successfully used as part of Microsoft Active Directory, and for which most mainstream OSes still include support. This allows any application on your machine to inherit that auth without ever seeing a single login screen.

While it can't easily be used cross-companies (and thus why SAML/OIDC exists), it's perfect for internal company infrastructure, and SAML/OIDC can still be handled somewhat seamlessly by having a minimal service that verifies your Kerberos identity and immediately dispatches you back to whatever third-party service you wanted to authenticate to, with no intermediate login pages or even any kind of UI (this service doesn't need UI because your authentication is managed via Kerberos for which your OS provides the UI).

The problem is that you can't make money (nor "growth & engagement") off stable, battle-tested stuff that already exists and happily works in the background, so Okta/etc shareholders need to peddle worse solutions that waste everyone's time and processing power.

Kerberos relies on line of sight to the TGS. In the '90s and '00s, this was common place. As of COVID, less so.

Kerberos is also difficult to administer and secure (Golden Ticket?). Kerberos also requires the target service be a member of the Kerberos Realm (or otherwise trusted) which again means line of sight between the service and TGS or Realm to Realm.

And then we get into the whole ticket size issue.

Kerberos is not a good candidate for web-based AuthN.

> Kerberos relies on line of sight to the TGS

Isn't this the same with any SSO provider? The SSO provider must be reachable by the end-user's browser during any authentication operation.

(in case of KB it must be reachable by the target services too, but in a server-to-server environment it's less of an issue)

> Golden Ticket

Isn't this exactly the same to let's say a session cookie of a web-based IdP?

The IdP could apply policies on its backend that bind the cookie to a given IP address, user-agent or other indicators, but can't this also be done for Kerberos tickets using a server-side middleware on every service you wish to access (since KB is internal-only, it shouldn't be that big of a deal)?

> Isn't this the same with any SSO provider?

Yes, but OAuth has one major upside: HTTPS only.

No one wants to create site-to-site VPN networks to flow Kerberos.

Isn't Kerberos explicitly designed to run over untrusted networks and not require any additional transport encryption?

You could argue that the common implementations are large piles of legacy C with questionable memory safety that could open them to exploitation by malicious actors, but that's an implementation detail rather than the protocol itself - and I believe there's at least one (mostly?) memory-safe implementation in Java called Apache Kerby.

I think "successfully bastardized" as part of their embrace, extend, extinguish campaign is more accurate.

IIRC you could make AD act as standard Kerberos+LDAP with one or two registry tweaks.

SSO can seem intimidating to someone new to authentication implementations. I think this is in part because it is a bit complicated but also because it is an inherently invisible technology which we dont need think about as users. Sign in with fb/google on the other hand is something we all see in our day to day business and have at least some kind of mental picture of how it works. We've also seen it used as authentication for otherwise poorly implemented services so we might think that "since they managed to use it, how hard can it be?". Hence, a lot of developers and product owners choose those instead of SSO.

Google and Microsoft are the worst for this. When you sign on you can see it flashing through several of their products, signing you on in each, before finally redirecting you to wherever you intended to go.

It might be done for user retention reasons with the idea that people are more likely to use sites they're already signed into, but I really don't need to be signed into YouTube when I sign into my Google work account. Please just skip that and sign in a few seconds quicker.

I'm pretty sure Google does it to set all the appropriate cookies on the right domains. Microsoft probably has similar redirect flows.

You can either do the redirects all at once on login or do them once you use the service first. Since login is already a time-consuming process (username, next, password, next, 2FA, next) I think you may as well take a second to add the redirects and be done with it.

It doesn't make much sense for Google work accounts but it makes sense if those are a minority on the platform. They could definitely patch this out, but then again the login process is something that takes a second extra every month or so, so who really cares.

What does bother me is how every service wants you to enter your username and password separately now. Autofill gets confused and sometimes even stops working because the stupid hidden input fields for the password don't get shown until you click the magical "next" button, just in case you need a special third party auth service.

Either decide that work accounts are important and take out the extra YouTube redirect, or decide they aren't important and let me fill in my username and password on a single form. Both make complete sense individually but combined they're just a massive waste of time.

When I've done login screens, I usually also include a hidden password field so that the password manager can autofill... this way, it's already filled when the password field is visible after clicking "next". It's at least an improvement to the workflow for those of us using a password manager.

Explaining it to the SecOps person, that was painful though.

It's because Microsoft and Google are the two largest identity providers around. Microsoft has M365 logins that can be configured with about 12 different authentication systems, as well as the various services like outlook.com, Hotmail etc. It has to check the login against those systems and then redirect you to that system.

Modern browsers heavily restrict cookies. The redirect chain right after login, that takes you through all subdomains, is a way to evade cookie restrictions if your sites use different domains.

Ten years ago I worked at a very large cloud company and I spent a lot of time wrestling with the various login flows. I remember seeing a flowchart that documented over 100 service calls that happen in the course of the 4 redirects that took place during a login.

I pay my water bill on my phone using cellular data because some part of the sign-in process hits an address that's blocked by the adblock DNS I use.

This is the worst. You can't even click an internal site link anymore without being redirected through several scummy third-party domains, so that some knucklehead product manager can claim that they are tracking "engagement" and show off "metrics" to their upper managers.

This is also a security and GDPR liability, if only it was enforced.

Could be anything from a SPA that has to be reloaded entirely to loading a ton of 3rd party JS to work with all those login with options.

I use Firefox containers with Temporary Containers (https://addons.mozilla.org/en-US/firefox/addon/temporary-con...) so oh boy do I deal with this a lot. With some hacking I can stop the page at the right time to make it 'always open in X container' - there doesn't seem to be an obvious way to glob for different subdomains.

Some of it has to do with changes to browsers’ acceptance of cookies. If you need to set cookies on multiple domains you control (common for SSO), you used to be able to do it by loading a pixel image or tiny script from each domain. Now, however, that’s considered a third-party cookie, and rejected by many browsers. The only reliable way now is to redirect the whole page, and then redirect back.

My university portal login flow (Microsoft login via university SSO), frequently has me log in with password+2fa+nag screen to use microsoft authenticator, just to then randomly fail and have me do the entire thing again. It is infuriating, especially since any login cookies appear to only be valid for 1-2 days per device.

I suspect that the amount of time I spend on just logging in to websites each day is upwards of 5 minutes, and I doubt it will decrease over the coming decades. Such a waste.

First issue is likely solvable by your IT department by looking through the AAD sign-in logs for your activity.

The second is because authentication is per-device (and depending on the scenario, per-app). The token lifetime is configured by your IT department. Microsoft's default is 365 days, if I recall.

The last time I logged in to AWS, the process went something like this, I may have left out or mistaken a step or two:

Go to login page

Solve capcha to get to login prompt

Enter user name, get sent to next page

Enter password

Enter MFA code

Failed, try resynching MFA token

Repeat login process

Failed, try rescynching MFA token again

Failed, repeat login process and then go to troubleshoot MFA link on mfa page

Enter password again

Go to altternative factors link

Click link to send verification email

Didn't get email, click link again

Click link in verification email

Click link on login page to get a phone call with a code

Get a call but it doesn't give me a code, try again

Still no code, try again

Get a code this time from the call but the code fails verification, try again

Get a code and it gets verified, sends me to a login page

Solve a capcha

Enter username and password, get logged in

Fortunately, I have found a solution to ensure this series of issues does not reoccur.

Fortunately, I have found a solution...

And I suppose the margin is too narrow to contain it?

(Care to share?)

That would be OAuth - https://en.wikipedia.org/wiki/OAuth.

It's a standard meant for system A to authenticate a user with system B. Ever logged in to a website with your Google account, or seen those permission screens asking you if you want to allow a third party website to access your Google account? That's OAuth.

Now, as to why many websites do this even when you login with credentials for that system (and not third party auth) - my guess is the system has separate teams for each subsystem, each hosted on different subdomains. In order to transfer auth state from one subdomain to another, you need something like OAuth since cross-domain cookies are forbidden by the browsers.

> what's going on here and how every single website has this new slowness

Everyone and everything uses OAuth/OIDC.

Your browser gets bounced between different sites that don't have the full picture because the process is optimized for the explainability of each part of the system instead of the performance of the whole system. It's something like: the website says "go to Microsoft to get signed in" and then microsoft.com says "actually Microsoft logins are now Live logins so go to login.live.com" and then that says "oh hey, you are already authorized, let me return this result back to Microsoft.com" which then says "oh hey, here's your result, pass it to yourwebsite.com". Something like that. Not exactly that. The point is: nobody has responsibility for the system. People only have responsibility for parts and Conway's Law applies.

I'm gonna guess here that the biggest chunk is the antivirus. Turning off Windows Defender's protection(s) should give the first visible speed boost, if that's what you prefer.

Another big chunk of this likely happened when they hardened the graphics subsystem for security. Win32 user calls are unbelievably expensive nowadays. SendMessage etc. have a ton of overhead.

Another chunk is likely the sheer number of expensive DLLs that need to be loaded and initialized with most apps. For example, IIRC, the moment you load COM or WinSock DLLs, your app stops loading snappily. Pretty much anything will load COM even without intending to.

Another chunk is IMM - the ctfmon process you love, for multi-language/keyboard support. ImmDisable(0) can make loading a bit snappier, but then good luck with keyboard switching and the like. It uses window hooks, which are slow Win32 calls as mentioned.

People think it's just a matter of writing plain Win32, but that's not the whole story, although it certainly helps compared to more heavyweight frameworks.

> Turning off Windows Defender's protection(s) should give the first visible speed boost, if that's what you prefer.

It's extremely hard to do that in recent versions of Windows. The most I managed to do the last time I tried was to disable it temporarily but it always comes back after a while.

Yeah, unfortunately you need to do it with group policy.

As far as I can tell they've removed the ability to turn off real-time scanning with group policy, so you have to disable the entire thing and not get on-demand or scheduled or download scans.

Defender will disable itself if it detects another AV product is installed...maybe someone should make one that acts as a no-op AV scanner.

Seems to be working for me still, though I set the GPO back on Win10 and it carried over to Win11 through an upgrade. I see some reports of needing to disable tamper protection first but should still work.

Ah yes, you need to disable tamper protection as well. (Which is kind of strange... if a virus can disable the first one can't it also disable the second one??)

There is a great script on GitHub which will disable it to the core.

A couple of years ago I was doing a mass copy of files from one SSD to another. It was a few hundred GB, not terribly big on modern machines but it did have a large number of tiny files. Windows was doing the copy but it was estimating that the whole thing would need 8 hours to complete, and the estimate was pretty solid after 20 minutes. I cancelled the copy to investigate and tried turning off Windows Defender (but only temporarily as you said) and restarted the copy. It finished in 35 minutes. Probably would have been even faster if I didn't have one of the drives hooked to an old USB->SATA adapter.

This is also why your browser will stall out when it finishes downloading a large file. Windows Defender kicks in an does a full scan before returning from the close call.

I’ve wanted to use one of those “gaming focused” stripped down windows installs for the longest time because all of the garbage is removed. It’s like Linux but not a pain in the ass for playing games and doing mundane shit. Too bad I care about security

It's easy to do. You set exclusions for whole root drive letters. It scans nothing for me on Windows 11

The AV stuff is huge. It’s always why windows Windows 8 era PCs were maybe the most brutally slow.

SSDs mitigate those issues but it is so painful to run things on mechanical drives, a lot of which is down to the antivirus processes. The practical realities have changed.

(Also things being snappy and fast I don’t think is a common memory of people when the machines the author is writing about were contemporary. The world of software is much bigger than notepad and cmd.exe)

> The AV stuff is huge. It’s always why windows Windows 8 era PCs were maybe the most brutally slow.

IIRC Win8's also the first Windows I found unusable on spinning rust. Part of it may have been AV, but things like opening the start menu had significantly worse delays there than on a flash disk. It seems like they'd simply disregarded all development/design discipline about disk I/O, across the OS.

... which, you keep doing that everywhere, lots of devs making lazy choices to just grab this from disk here or just write a little data synchronously there, and it'll add up to non-negligible delay, even on a flash disk. And it'll make an HDD craaaawl. Which is exactly what happened.

Yes. It’s a combination of those factors for sure. There are just so many more constant disk hits from 8 and on, and a good deal of them are from Defender. I do PC service and repair on the side and tossing in a cheap SSD makes most people happy because the drive being slammed was the only thing “wrong” with their computer.

Thankfully we’re largely past that.

That said, I rarely see malware on most of the machines I touch. I get more calls about automatically fullscreened browser windows with scare text and a phone number to call than any actual software problems.

Defender does work well enough for any average person and I’m happy if only because the vast majority of AV software is sold in the most disgusting way. Just as bad as the malware scare tactics honestly.

It's interesting too because AV feels somewhat less useful than ever - we're not in the days of common worms flying around the internet anymore, we're in the days of script kiddies using commercial "FUD packers" to bypass most AV scanners with their password and token stealers so they can resell the accounts.

Tools like that are basically hit-and-run and they don't need to stick around to do lasting damage.

Yes a lot of them don’t stick around, so the only real solution is to bear the cost of real-time AV scanning

Real-time AV scanning is useless against even a cheap (<$10) packer though. Sure, they'll update their definitions and find it eventually, but if it doesn't have a definition for it now, having a definition for it later simply doesn't matter, the damage is done. I'd argue you're actually better to run it through something like VirusTotal where they'll have a larger assessment from many scanners and sandboxing tools to increase the odds of catching something compared to real-time scans with 1 AV.

You don't need to turn off Windows Defender, you need to disable the file system filters entirely.

You can do that with Dev Drive [0][1] which is currently on the Win 11 dev branch.

You can't do this for your boot volume, but you can do it for a [dynamically expanding] VHDX, secondary partition, or secondary volume. It will use ReFS (oddly enough, with 4 KiB clusters by default -- though it makes sense for the target scenario, unlike past uses of ReFS).

[0] https://learn.microsoft.com/en-us/windows/dev-drive/

[1] https://blogs.windows.com/windowsdeveloper/2023/06/01/dev-dr...

> You don't need to turn off Windows Defender, you need to disable the file system filters entirely.

> You can't do this for your boot volume

How would this help with firing up all the built-in OS apps (Explorer, Notepad, etc.) being tested in the video?

It certainly wouldn't (though I don't experience the same issue, so not sure what to say to the video). Presumably your heavier apps would be installed to the Dev Drive.

How did I not hear about this before on HN? This is pretty cool.

We just rely on layers and layers of cruft. We then demand improvements when things get too bad, but we're only operating on the very top layer where even dramatic improvements and magic are irrelevant.

Windows is especially bad at this due to so much legacy reliance, which is also kind of why people still bother with Windows. Not to claim that Linux or MacOS don't have similar problems (ahem, Catalyst) but it's not as overt.

A lot of the blame gets placed on easy to see things like an Electron app, but really the problem is so substantial that even native apps perform slower, use more resources, and aren't doing a whole lot more than they used to. Windows Terminal is a great example of this.

Combine this with the fact that most teams aren't given the space to actually maintain (because maintaining doesn't result in direct profits), and you've got a winning combination!

Not only that. It's not Wirth's Law.

It's the fact that manpower can't keep up with the exploding amount of complexity and use cases that happened to computing in the last decades.

We went from CLI commands and a few graphical tools for the few that actually wanted to engage with computers, to an entire ecosystem of entertainment where everyone in the world wants 'puters to predict what could they want to see or buy next.

To maintain the same efficiency in code we had in the 90-2000s, we would need to instantly jump the seniority of every developer in the world, right from Junior to Senior+. Yes, you can recruit and train developers, but how many Tanenbaums and Torvalds can you train per year?

The biggest amount of cruft not only went to dark patterns and features in programs like animations and rendering that some people regard it as "useless" (which is debatable at minimum). But the layers went also to improve "developer experience".

And I'm not talking about NodeJS only. I'm talking about languages like Python, Lua, or even the JVM.

There's a whole universe of hoops and loops and safeguards made so that the not-so-genius developer doesn't shoot themselves in the foot so easily.

I'm sure that you can delete all of that, only leave languages like Rust, C and C++ and get a 100x jump in performance. But you'd also be annihilating 90% of the software development workforce. Good luck trying to watch a movie in Netflix or counting calories on a smartwatch.

I'm afraid you're putting too much weight on language. Windows is largely built on C++, no? The impact of adding features, multiple layers of architecture, maintained by many people over a long time is worse. Don't underestimate the capacity of creating slow software in ANY language. Software architecture and project management are unsolved problems in the industry.

Windows uses C# a lot.

Windows is a behemoth of legacy protocols, abandoned projects, and software support that ranges from bleeding edge gaming hardware to obscure ancient machines required by long term support partners and investors.

Devs at MS have to make everything right in an universe where everything else is dead or crap. And the fact that Windows 11 can even run without crashing daily is an engineering marvel.

PD: Not to defend MS, but I'm sure their current devs are very capable and doing their best.

>Windows is largely built on C++, no?

Microsoft has been trying to migrate Windows development to a managed language for over 20 years; their first attempt at this was a complete disaster and NT 6.0 (Vista) would ultimately be developed the old way.

It's only really been in the last 5-7 years, with Windows 10 and 11, that MS has managed to get their wish as far as UI elements go, which is why the taskbar doesn't react immediately when you click on it any more and has weird bugs that it didn't have before.

Oh please, get over yourself. How many of those oh so smart 90s devs used those elite skills to write code littered with exploit vectors? Or full of bugs? Or, hell, even really performant?

You are looking back with rose tinted glasses if you think all software was blazing fast back then. There was a reason putting your cursor on a progress bar to track whether it was moving was a thing.

> There was a reason putting your cursor on a progress bar to track whether it was moving was a thing.

The reason it's not a thing today is because those progress bars got replaced by spinners and "infinite progress bars". At least back then you had a chance to learn or guess how long slow operations would take. These days, users are considered too dumb to be exposed to such "details".

The real reason people moved to the infinite ones is that the determinate progress bar is almost never accurate or representative, hence useless.

Like beyond truly "dumb" tasks like downloading a file it's basically a guessing game how long it will take anyway, right? Say you split the whole loading bar into percentages based on the number of subtasks, suddenly you end up with a progress bar stuck on 89% for 90% of the total loading time.

Obviously you could post-hoc measure things and adjust it so each task was roughly "worth" as much as the time it took, but people rarely did that back in the day and my boss would get mad at me for wasting time with it today. Hence, spinners.

> Say you split the whole loading bar into percentages based on the number of subtasks, suddenly you end up with a progress bar stuck on 89% for 90% of the total loading time.

Sure. But now as a user, I get to see the glimpse of what's going out under the hood. Combined with other information, such as a log of installation steps (if you provide it), or the sounds made by the spinning rust drive, those old-school determinate progress bars were "leaking" huge amount of information, giving users both greater confidence and ability to solve their own problems. In many cases, you could guess the reason why that scrollbar is stuck on 89% indefinitely, just by ear, and then fix it.

Conversely, spinners and indeterminate progress bars deny users agency, and disenfranchise them. And it's just one case of many, which adds up to the sad irony of UI/UX field - it works hard to dumb down or hide everything about how computers work, and justifies it by claiming it's too difficult for people to understand. But how can they understand, how can they build a good mental model of computing, when the software does its best to hide or scramble anything that would reveal how the machine works?

> everyone in the world wants 'puters to predict what could they want to see or buy next.

This doesn't strike me like something "everyone in the world wants", but rather something a small group of leaches is pushing on the rest of the population, to enrich themselves at the expense of everyone else. I'm yet to meet a person that would tell me they actually want computers to tell them what to see or buy. And if I met such person, I bet they'd backtrack if they learned how those systems work.

Exercise for the reader: name one recommendation system that doesn't suck. They all do, and it's not because recommendations are hard. Rather, it's because those systems aren't tuned to recommend what the users would like - they're optimized to recommend what maximizes vendor's revenue. This leads to well-known absurdities like Netflix recommendations being effectively random, and the whole UX being optimized to mask how small their catalogue is; or Spotify recommendations pushing podcasts whether you want them or not; or how you buy a thing and then get spammed for weeks by ads for the same thing, because as stupid as it is, it seems to maximize effectiveness at scale. Etc.

> I'm sure that you can delete all of that, only leave languages like Rust, C and C++ and get a 100x jump in performance. But you'd also be annihilating 90% of the software development workforce. Good luck trying to watch a movie in Netflix or counting calories on a smartwatch.

I'll say the same thing I say to people when they claim banning ads would annihilate 90% of the content on the Internet: good. riddance.

Netflix would still be there. So would smartwatches and calorie counting apps. We're now drowning in deluge of shitty software, a lot of which is actually malware in disguise; "annihilating 90% of the software development workforce" would vastly improve SNR.

For the most part, that 90% of the development workforce is not working on solving a new and unique use case, but rather solving an already solved use case but for yet another walled garden (think Disney+, Amazon Prime Video, HBO Max, etc. or the analogous diaspora of fitness tracking apps).

The early 00’s “open standard” of web forum + eMule + VLC would still be light years ahead of Netflix&co. if it weren’t for how hard it’s been gutted by governments, copyright lobbies, ISPs and device/platform vendors through the years. Heck, the modern equivalent often still is (despite all the extra hoops), unless you are trying to watch the latest popular show in English.

Sorry but Windows Terminal is a terrible example of this. It does way, way more than cmd.exe.

They might be referencing the “controversy” around it, where a prominent developer claimed and later proved that the terminal’s render speed is simply orders of magnitude slower than it could be.

It later turned out to be due to some Unicode handling in-built into a windows api they were using, while the developer’s version also not completely feature-complete. But both sides were sort of right.

> Windows is especially bad at this due to so much legacy reliance

Part of the "problem" with Windows is also lack of legacy reliance. As in: MacOS and Linux are at heart Unix systems, with a kernel architecture meant for 1970s hardware. The Windows NT kernel family is a clean-sheet design from the 1990s, a time where compute resources were much more plentiful.

For example, on Linux file system access has (by default) very basic permissions, and uses a closely coupled file system driver and memory system in the kernel. On Windows there is a very rich permission system, and ever request goes through a whole stack of Filesystem Filter Drivers and other indirections that can log, verify or change them. This is great from a functionality standpoint: virus scanners get a chance to scan files as you open them and deny you access if they find something, logging or transparent encryption is trivial to implement, tools like DropBox have an easy time downloading a file as you access it without dealing with implementing a whole file system, the complex permission system suits enterprise needs, etc. But on the other hand all these steps make the system a lot slower than the lean Linux implementation. And similar resource-intensive things are happening all over the kernel-API in Windows, simply because those APIs were conceived at a time when these tradeoffs had become acceptable.

> On Windows there is a very rich permission system, and ever request goes through a whole stack of Filesystem Filter Drivers and other indirections that can log, verify or change them. This is great from a functionality standpoint: virus scanners get a chance to scan files as you open them and deny you access if they find something,

Yes, but still it seems to be useless to implementers, because practically every virus scanner implements braindead stuff like DLL injection for on-access-scanning.

> The Windowsw NT kernel family is a clean-sheet design from the 1990s

I thought that the NT Kernel was heavily based on VMS. When Dave Cutler, their chief OS architect/guru left for Microsoft and took a bunch of engineers with him. FTA:

"Why the Fastest Chip Didn't Win" (Business Week, April 28, 1997) states that when Digital engineers noticed the similarities between VMS and NT, they brought their observations to senior management. Rather than suing, Digital cut a deal with Microsoft. In the summer of 1995, Digital announced Affinity for OpenVMS, a program that required Microsoft to help train Digital NT technicians, help promote NT and Open-VMS as two pieces of a three-tiered client/server networking solution, and promise to maintain NT support for the Alpha processor. Microsoft also paid Digital between 65 million and 100 million dollars."

[0] https://www.itprotoday.com/windows-client/windows-nt-and-vms...

I have mixed feelings about Catalyst, but at least it moves in lockstep with iOS advancements/deprecations and isn't holding macOS development back for the sake of backwards compatibility with some obscure thing from 20+ years ago.

> A lot of the blame gets placed on easy to see things like an Electron app

I think this blame is fair. Electron is the most obvious example, but in general desktop software that essentially embeds a full browser instance because it makes development slightly easier is the culprit in almost every case I've experienced.

I use a Windows 10 laptop for work.[1] The app that has the most lag and worst performance impact for as long as I've used the laptop is Microsoft Teams. Historically, chat/conferencing apps would be pretty lightweight, but Teams is an Electron app, so it spawns eight processes, over 200 threads, and consumes about 1GB of memory while idle.

Slack is a similar situation. Six processes, over 100 threads, ~750MB RAM while idle. For a chat app!

Microsoft recently added embedded Edge browser controls into the entire Office 365 suite (basically embraced-and-extended Electron), and sure enough, Office is now super laggy too. For example, accepting changes in a Word doc with change tracking enabled now takes anywhere from 5-20 seconds per change, where it was almost instantaneous before. Eight msedgewebview2.exe processes, ~150 threads, but at least it's only consuming about 250MB of RAM.

Meanwhile, I can run native code, .NET, Java, etc. with reasonable performance as long as the Electron apps aren't also running. I can run multiple Linux VMs simultaneously on this laptop with good response times, or I can run 1-2 Electron apps. It's pretty silly.

[1] Core i5, 16GB RAM, SSD storage. Not top of the line, but typical issue for a business environment.

Don't blame Electron for Teams. It certainly doesn't help, but there's plenty of Electron apps that are perfectly functional and fairly snappy. Just compare it with VS Code. Same company, both Electron apps. The difference is astonishing.

Create a cross-platform UI toolkit that is easy to use, has all the accessibility features of the browser built in, and has a UI control toolkit as rich as say mui.com ... Support SVG as well as stylized layout similar to html+css.

It's not an easy task, and it's not something that anyone has really done. There are plenty of single platform examples, and Flutter is about as close as you can get in terms of cross platform.

There are also alternatives that can use the engine of an installed OS browser. Tauri is a decent example for Rust. Also, Electron isn't to blame for the issues with Teams. VS Code pretty much proves you can create a relatively responsive application in a browser interface.

it's not something that anyone has really done

It has been done many times.

Not only that, if you want to use a web page for a GUI, then do it by making a local web server back end and just use the web browser.

This idea that electron is somehow the only way to get cross platform GUIs is some sort of bizarre twilight zone where a bunch of people who only know javascript ignore that last three decades of software.

Okay, care to name some of these many cross-platform, easy to use UI toolkits that include the accessibility that the browser has?

Also, I never said Electron was the only way... I specifically mentioned Tauri in my comment as an example of a browser renderer. And it doesn't need to use a local web server either.

Qt, FLTK, WxWidgets

And it doesn't need to use a local web server either.

Shipping an entire browser so someone can pop up a single window is not a positive. Again, if you want html as your interface, use html and let people use their own browser so that the entire program is 400KB instead of 400 MB

Qt, open-source only or expensive licensing. C++ only bindings... wouldn't call it "easy to use"

FLTK, no accessibility features

WxWidgets, really limited theming, not even close to html+css. Cross platform compatibility is hit and miss, usually requiring a lot of one-off platform corrections.

Also, as I said, you don't need to ship the entire browser... not once, but twice... try reading slower.

Qt has been LGPL for ages. You can use it for free just fine in proprietary apps, as long as you don't modify Qt itself.

Sorry, I had forgotten.

Qt, open-source only or expensive licensing

It's LGPL, lots of programs use it like qTorrent, VLC and much more. You can make up criticisms but it has been a backbone of GUIs for decades.

FLTK, no accessibility features

What exactly do you need and do you need it for every GUI you make? If you want a web page, use a web page.

WxWidgets, really limited theming,

Suddenly theming is your deal breaker.

not even close to html+css

Thankfully, because that is often not a good way to make a GUI.

as I said, you don't need to ship the entire browser...

No, you said "it doesn't need to use a local web server either." Also 'entire web browser or not' electron programs end up being hundreds of megabytes for a simple window use hundreds of megabytes of RAM.

The bottom line here is not that electron is necessary. It is that you want to use javascript even though your users will hate it.

> What exactly do you need and do you need it for every GUI you make?

A GUI toolkit that has no support for screen readers, or other assistive technologies that require accessibility APIs, should be a non-starter for most applications IMO. We need more options that meet that criterion without going all the way to a web page.

How is electron better than a web page for accessibility?

Browsers/Electron has great accessibility in the box.

What does that mean and how does that answer the question? How is electron better than using a local webserver and web page for accessibility?

Well, I've specifically stated more than once, you don't need to use Electron specifically. The advantage Electron does provide is relative isolation from your installed browser (which are generally well sandboxed anyhow). The only other significant advantage is they are easier to jail/isolate for use with the likes of appImage, Snap and Flatpak/Flathub. So you can target multiple Linux platforms with a single build process, without dependency hell or getting stuck on older repository releases. Electron also offers a consistent option for your application's packaging and updates along with a consistent browser surface, where a separately packaged application that uses the system's browser will be indeterminant in terms of potential render issues and bugs.

Again, not that I'm advocating for Electron specifically, and haven't been. I've specifically mentioned Tauri and others as alternatives that use the system's browser engine, which you have repeatedly ignored.

relative isolation from your installed browser

What does this mean? What specifically do you think is being prevented?

The only other significant advantage is they are easier to jail/isolate for use with the likes of appImage, Snap and Flatpak/Flathub.

How is a program with hundreds of megabytes of dependencies easier than a single small statically compiled binary?

Again, not that I'm advocating for Electron specifically,

This thread was about people using electron even though users hate it.

From my original comment, "cross-platform UI toolkit that is easy to use, has all the accessibility features of the browser built in, and has a UI control toolkit as rich as say mui.com ... Support SVG as well as stylized layout similar to html+css"

So, you've failed to meet the requirements from the start.

I've also said, many times now, that you can use browser tech without an entire browser and the answer doesn't need to be electron.

Sorry, accidentally replied under the wrong post below.

It's been done many times. HTML/DOM is a very primitive UI toolkit by any measure, even with extensions like mui.com beating it is not all that difficult. Are a few open source hackers going to manage - no. Can other companies manage it, yes. Especially accessibility really isn't as hard as people sometimes make out on this forum, and HTML isn't that good at it (because it lacks a lot of semantic information by default).

Consider the feature set of JavaFX when used in combination with the AtlantaFX theme/widget pack. It isn't well known, but is maintained and has an active open source community today.

- All the same controls as mui.com shows and more advanced ones too, like a rich text editor, a way more advanced table view, tree views, table tree views, etc.

- Media and video support.

- 3D scene graph support. HTML doesn't have this! If you want to toss some 3D meshes into your UI you have to dive into OpenGL programming.

- When using FXML, semantic markup (<TabView> etc)

- Straightforward layout management.

- A dialect of CSS2.something for styling, a TextFlow widget for styling and flowing rich text.

- Fully reactive properties and collections, Svelte style (or moreso).

- Icon fonts and SVG works.

- Sophisticated animations and timelines API.

And so on. It's also cross platform on desktop and mobile, and can run in a web browser (see https://jpro.one where the entire website is a javafx app), and can be accessed from many different languages.

Flutter is actually not quite as featureful in comparison, for example there's no WebView control or multi-window support on desktop, though Flutter has other advantages like the hot reload feature, better supported mobile story. The community is lovely too.

Then you have AppKit, which is also very feature rich.

So it's definitely a task that people have done. Many of these toolkits have features HTML doesn't even try to have. The main thing they lack is that, well, they aren't the web. People often find out about apps using hypertext and being able to have a single space for documents and apps is convenient. When you're not heavily reliant on low friction discovery though, or have alternatives like the app stores, then web-beating UI toolkits aren't that big of a lift in comparison.

> Electron isn't to blame for the issues with Teams. VS Code pretty much proves you can create a relatively responsive application in a browser interface

Electron is great, but most apps aren't VS Code. On my 2019 Intel MacBook Terminal.app starts in <1 second and WhatsApp starts in about 7 seconds. Electron is Chrome and Chrome's architecture is very specifically designed for being a web browser. The multi-process aspect of Chrome is for example not a huge help for Electron where the whole app is trusted anyway, though because HTML is so easy to write insecurely, sandboxing that part of it can still be helpful even with apps that don't display untrusted data. That yields a lot of overhead especially on Windows where processes are expensive.

The jpro.one website looks like it's rendering in the browser to me, are you sure the "standalone" and "cross-platform" options aren't also using a browser render surface?

I also said, "Flutter is about as close as you can get" regarding coming close to what I was referring to.

AppKit is NOT cross-platform. Beyond this, you have other means of embedding a browser-ui application without all of chrome included, see Tauri as one example.

JPro runs the app server side, but the UI is rendered to a stream of commands that are then interpreted by the client in the browser to draw using divs, SVG and browser text. The result is that scrolling, text rendering, fills etc are done by the browser but all the actual app logic is server side. However event handling is all server side. If you run the same app on the desktop then it uses its own rendering stack.

> Especially accessibility really isn't as hard as people sometimes make out on this forum

Just to make sure I'm not being one of those people: What AccessKit [1] has now, across Windows, macOS, and Linux, took roughly six person-months of work. We still need to support more widget types, especially list views, tables (closely related), and tree views, but we do already have text editing covered on Windows and macOS. Perhaps it helps that I'm an accessibility expert, especially on Windows. Anecdotally, it seems that implementing UIA from scratch is daunting for non-experts. But I guess in the big picture it's really not that hard.

[1]: https://github.com/AccessKit/accesskit

We need linux to add electron or an equivalent directly to the OS. Cut out the browser and the bullshit. Allow meme developers to write in meme languages but still get good performance.

>We need linux to add electron or an equivalent directly to the OS.

Almost like some kind of... web OS?

To think we almost had it, but Palm made some bad decisions back in 2009 and the dream of app-as-browser + Node.JS + consistent application styling and syscalls through a provided JS framework (Enyo) is, sadly, probably dead forever.

Tauri, Photino, DeskGap and others have this.. it's not as consistent, and does vary by development language and platform. It has been relatively approachable however. Electron is of course a bit more popular and does bring a bit more to the mix.

> because it makes development slightly easier

That "slightly" is doing a massive amount of heavy lifting in that sentence.

I run a company on the side that produces software for events which require a website and mobile apps for iOS (iPhone and iPad)/Android. I cannot imagine being able to do this all on my own without being able to share a codebase (mobile apps built via Capacitor) across all of them. Would native apps be faster? Almost certainly but I'm not going to learn Kotlin and Swift and triple the number of codebases I have to work it. It's completely infeasible for me, maybe some of you are able to do that but I'm not, there aren't enough hours in the day.

I fully understand the cruft/baggage that methods like this bring but I also see first-hand what they allow a single developer to build on their own. I'll take that trade. I'm a little less forgiving of large companies but Discord and Slack (and other Electron apps) work fine for me, I don't see the issues people complain about.

> work fine for me, I don't see the issues people complain about.

What are the specs on the machine you're using?

Teams has at least 2, maybe even 3 people working on it.

While you are definitely right to a degree, let’s also not forget that depending on how far we go back, everything was English, ascii-only with no accessibility and security.

By requiring more than that, we had to increase the essential complexity. I believe this tradeoff in itself is well worth it (and hopefully we can all agree on that going back to us-ascii-only locale is not a forward direction).

The problem I see is that the layers you also mention, each expose leaky abstractions (note that abstractions are not the problem, no person on Earth could implement anything remotely useful without abstractions — that’s our only tool to fight against complexity, of which a significant amount is essential, that is not reducible). Let’s also add a “definition” I read in a HN comment on what constitutes an ‘expert’: “knowing at least 2 layers beneath the one one is working with” (not sure if it was 1 or 2).

Given that not many people are experts and a tendency of cheaping out on devs, people indeed are only scratching that top layer (often not even understanding that single one!), but the problem might also be in how we organize these layers? When an abstraction works well it can really be a breeze and a huge (or only significant, see Brooks) productivity boost to just add a library and be done with it — so maybe the primitives we use for these layers are inadequate?

> no accessibility and security

Not my area but AFAIK modern (electron based) desktop apps are less accessible then classic win32 apps from win2k - win7.

>We just rely on layers and layers of cruft. We then demand improvements when things get too bad, but we're only operating on the very top layer where even dramatic improvements and magic are irrelevant.

You just describe modern Web Development.

I have been saying this for a decade. Technology is getting worse as a whole. Hardware is continuing to improve, but the software is getting worse at a faster rate, making the overall product suck more.

One of the reasons is the whole "software is a gas" thing. As long as there is faster hardware, more memory, more storage, software will get slower, more bloated, and take up more space, just because a gas always fills its container.

But another reason is there's more people in tech who don't know what they're doing. More people who took a bootcamp and jumped into a job, or came from some other career and barely know how to use a computer, never used Linux/UNIX. Some newer roles have very specific niches, where they don't know much about tech, and then they're asked to write code, which they have almost no idea how to do. I've recently worked with colleagues who were contributing code, and getting in the way of building the product, who shouldn't have been within 10 miles of an IDE. And when the senior developers don't know how environment variables work, I weep.

Out of curiosity, what did you do to work with (or around) said people? I guess your penultimate sentence implies you moved on.

I resign myself to let things be terrible. Leadership won't care to fix it until it becomes a problem for them, and that won't happen if I'm running around trying to plug the holes in the dyke. Since it's a big paycheck I stay and mentally check out, casually searching for something better.

The newest generations of children can barely read and write let alone use a computer.

It’s going to be fascinating watching what happens when there’s nobody left capable of updating things like linux. It will be like a black box, people can maybe scrape together an electron app but they don’t go any deeper.

Back then there was barely anyone that could update things like Linux, that's why most of us make a good living.

Millennials are the only generation who can deal with computers.

> when the senior developers don't know how environment variables work, I weep

I recently spent a hair-pulling near-week encountering then trying to figure out the DLL search path in Win32 because a library was messing around with it. Documentation is straightforward enough, I suppose, until you get to SetDefaultDllDirectories, which has this in its discussion: "It is not possible to revert to the standard DLL search path or remove any directory specified with SetDefaultDllDirectories from the search path."

I guess my point is, environment variables can be tricky.

Things Windows 10 has to content with when executing a new binary, that Windows 3.51 didn't

1. Windows Defender anti-virus checking the binary and contacting MS' server for binary signing/black list

2. Kernel32 trampolines

3. All sorts of security mitigation techniques such as stack cookies setup etc.

4. Telemetry

5. Hardware accelerated GUI initiation vs 'dump everything to frame buffer in kernel GUI32 library'

6. Load fonts, graphics etc. that can work well beyond 640x480

7. Deal with the scheduler juggling hundreds of processes that let you from accessing winsock2 lib immediately, to have multiplex sound mixing, to system restore, all in the background.

> Windows Defender anti-virus checking the binary and contacting MS' server for binary signing/black list

Are you sure this happens every time you start an executable? I assumed the definition list gets updated in fixed intervals instead of whenever you launch a program.

i would assume that the information "when does user start program" is valuable and the list is finite, so there is some incentive to go for something in between.

sure, makes me wonder how much of this list could be scratched w/o anyone noticing.

PS: ran w2k on a 1600x1200 21" crt

It depends, fonts sucked bad in windows those days.

8. Maybe out of topic but animations delaying the display of the window (can be disabled but is not on the video)

Windows 10 LTSC removes a lot of the crap - and even with defender and some of the other stuff you are talking about here it is insane responsive.

Good analysis.

> 5. Hardware accelerated GUI initiation vs 'dump everything to frame buffer in kernel GUI32 library'

Even on my fast workstation, this seems to account for most of the percieved startup latency in modern, well-written GUI applications. The Nvidia drivers seem to do this stupid signature check every time a d3d11 device is created..

Not gonna lie, my memory serves me well. I remember using Windows 98 on an old PC, and it was hot garbage. It took generations to boot up, and applications took generations to open. My story is anecdata, but so it this twitter post. These days I have an infinitely snappy experience with desktop linux on an SSD.

SSDs and adequate memory were the two things that happened where PCs finally started feeling snappy.

Another anecdote: I fixed up a computer running vista for a secretary once. It had been running with a hard disk and would take upwards of a minute to load. After replacing the HDD with an SSD, it booted so fast that you got thrown onto the desktop and all of the "startup sounds" played all at once, the system seemingly booting faster than it could cope with!

PCs were incredibly snappy before SSDs, and didn't need much RAM at all. Gnome 1.4 was like lightning, whereas KDE was noticeably slower.

You don't need fast hardware to have snappy apps. Most of the microcontrolled devices you deal with day to day are clocked between 4 and 25MHz. Hard drives are only needed to access files once and load them into memory, and microcontrolled devices have like 256kB-4mB of memory. The only reason apps aren't snappy is programmers fail to make proper use of the hardware and OS.

A good way to reality check this is to think about how frequently we saw loading splash screens then vs now. Back then it was common. Office suites, IDEs, browsers, pretty much any non-trivial app would show you a splash screen whilst it loaded. Some even had progress bars in the splash screens. Nowadays even web apps don't have splashes (though you could argue that grey loading flashers are the modern equivalent).

Many of those apps switched from using splash screens to pre-loading in the background.

Which ones?

I'd say it's not so big these days after SSD became the norm, but a lot of apps there for awhile would set a start up program in the system tray. That would preload most of the dlls in memory so when you ran the executable it loaded much faster.

Adobe, for example, has a ton of common libraries that load at startup.

A lot of that was simply down to how slow hard drives were back then. I can not overstate what a miracle of performance it is jumping from a 7200RPM (or 5400!) HD to today's solid state storage. Tens of thousands of times faster in many cases.

Many web pages have loading progress bars. They're usually only 1-2 pixels thick and take up the entire top 1-2 rows of pixels on the page. Some stuff loads asynchronously, so it can be easy to miss them, but I see them all the time. Just today, I was using Jenkins and it does that!

But if you compare data transfer speed of an IDE 33 rotating hard disk against a SATA (or better Nvme) SSD, and then, once data is transferred from storage you managed it in what amount of (much slower) RAM (at the most in 8 Mb in Win 3.x times, probably 48 or 96 Mb with win 9x, 128 or 256 Mb on NT 4.00 or 2K, while nowadays it is 4/8/16 Gb) and on a single core processor, running at 100-1000 Mhz, while nowadays you have likely minimum 4 cores runnning at 3,000 or something like that.

Sure you had splash screens, the sheer fact that you could open a spreeadsheet amd make some calculations (often with automatic calculation disabled and thus pressing F9 manually to re-calculate) was (IMHO) a miracle in Windows 3.x times.

This is a pet peeve of mine but today developers should be (only for testing their programs) be given the lowest powered machines available, connected to the same (shitty) internet connection a large part of the future users of the programs actually experience and see directly why their programs/tools/websites/whatever are laggish/slowish for their customers.

NT kernels were always better than the DOS-based hot garbage of 95, 98, and ME.

Windows 2000 is my all-time favorite Windows OS. NT-based kernel, literally nothing extra, fast, stable. Used it til the day support was finally shuttered.

GDI+ was slower due to the alpha transparency than GDI in NT4.

Any way to legally obtain win2k iso now? I lost my discs from that era and would like to run it in a VM.

WinWorld has been freely distributing copies of Windows 2000 for years now without issue.[0] Someone even tried reporting them to Microsoft and nothing happened,[1] even though WinWorld says they honor takedown requests.[2] It seems Microsoft really doesn't care as long as you stick to stuff older than XP.

[0]https://winworldpc.com/product/windows-nt-2000/final

[1]https://answers.microsoft.com/en-us/windows/forum/all/winwor...

[2]https://forum.winworldpc.com/discussion/6236/is-this-site-il...

In my experience it was the opposite. 98SE was great, ME was worse.

NT might be more stable but it was also much slower. DOS applications on 9x actually ran in a VM with hardware passthrough, whereas NT emulated much of the hardware via NTVDM. Interacting with something as simple as the EDIT text editor in a window on 2K/XP is noticeably slower than on 9x.

> In my experience it was the opposite. 98SE was great, ME was worse.

I think you're mixing up Windows 2000 and ME? ME was a rushed update of 98 because Microsoft felt "they should release something" for the Millennium. It was a dumpster fire. Windows 2000 was the continuation of Windows NT, and became the basis for XP and everything that followed.

As for performance, by the time Windows 2000 came out (Pentium 3 era machines) it didn't seem to matter that much any more, and it really was a lot more stable.

I remember when the Java load time was an issue, as it prevented Java apps from even displaying a splash screen while loading. Sun made a goofy manifest file feature to allow for it: https://docs.oracle.com/javase/tutorial/uiswing/misc/splashs...

I had the same experience.

I remember going to a friends house and using their computer, and it took several minutes to boot, and even after it reached the desktop it still took more time for things to become responsive. Opening any program took at least 10 seconds, possibly more.

Those old HDDs could only reach low double digit IOPS, so opening a program would cause the entire system to become unresponsive until it was loaded!

Modern SSDs are massively faster, and stay fast even when heavily used! Some of the modern SSDs are even faster when lots of operations are queued up!

Well of course it does.

WinNT 3.51 was released in 1995 - the fastest PC in 1995 was either a Pentium or Pentium Pro at ~100 MHz - in 2000 a 600 MHz machine is likely a Coppermine PIII.

A fairly common amount of RAM in 1995 to Run WinNT would have been around 32 megs of ram, 64 megs would be especially generous. 128 megs is a high end workstation amount of memory.

The ATA interface also doubled in performance between 1995 and 2000.

There were significant security and stability improvements between NT 3.51 and Windows 2000 - particularly with changes to the driver model that increased stability. (even more so between 2000 and Windows 10/11)

That's right, Windows 95 on a 600 MHz machine would be even snappier. However, later down the thread the author demonstrates Windows 2000:

>For those thinking that the comparison was unfair, here is Windows 2000 on the same 600MHz machine. Both are from the same year, 1999. Note how the immediacy is still exactly the same and hadn’t been ruined yet.

https://twitter.com/jmmv/status/1672073678102872065

I tested on my own local win10 VM, and I get similar performance for the inbuilt windows apps.

cmd, control panel, and most of the things in admin tools launch virtually instantly.

This is for a machine that is running on relatively slow spinning disks too.

As someone who was hardcore into Windows around that time, all my memory has is waiting desperately for windows to open & apps to load. I remember watching the left-side of explorer paint before the icons came in, and how the icons would paint in order; some days you’d see black squares paint, then the icon. This was running on some dual-socket, 192mb, 7200rpm spinning disk - it wasn’t a slouch.

I also struggle with the comparison between high-end hardware of yesteryear, and low end hardware of today and comparing.

Try running win2k in 16mb, 300mhz P2, and a 4800rpm drive.

The only times I remember experiencing things this fast in my computing career were (a) with a fair wind, and a fully warmed cache that didn’t hit the disk & was a trivial app (b) the first time I used my Apple M1 Max MBP.

Then don’t dodge the question and tell me the specs of the high-end computer that makes modern Windows that snappy. Because I have a fairly ridiculous machine as my main workstation, and I still wait way longer for stuff to load than I used to.

Core i5 or i7, 16-32gb of RAM, a NVME SSD

Single thread performance. My 13900k opens most things instantly, and it's a noticeable difference compared to even a 12900KS

> WinNT 3.51 was released in 1995 - the fastest PC in 1995 was either a Pentium or Pentium Pro at ~100 MHz - in 2000 a 600 MHz machine is likely a Coppermine PIII.

This is addressed in the linked thread.

In 1995 getting 128MB of RAM would have been quite expensive. In 1999 not so much. One of the easy things to do with NT or 98 in the 98-2000 era was to put 128MB of ram in when it suddenly became very affordable. It was a night and day experience. I had one game that ran absolutely rubbish in 1995 when I bought it. Years later I came across a few memory sticks and popped them in and gave the thing 16MB of ram from 8. The game started nearly instantly and ran very nicely (usually took 3-5 mins to start). With 8 it was choppy city and slow. Exact same computer only diff was the memory.

If memory serves me they did not really change much in NT from 4.0 to 2k. Other than add in more services and make it more win98 like. So it is maybe not an 'unfair' comparison. But win 3.51 came out getting that sort of computer just would not be in the cards for most people.

Windows went sideways at vista. The 'start the computer up' out of the box would use 2-3gig of ram. Up from 100-200MB from the XP era. Toss in some corp bloatware items. One place I saw it was 10gig just to open the desktop no productivity software even started yet. Then add in the zillions of indirect layers we have added to make programming easier and we are now with applications that seem to start at about the same rate as 25 years ago.

All of those old API's are still there. No one really uses them much anymore. We use the latest cool frameworks. That use the previous cool framework that eventually uses the old APIs :)

He did another video with Windows 2k.

Spoiler: it was still just as fast.

> Well of course it does.

Why does it follow that software designed for modern hardware, running on modern hardware, should be slower than software designed for older hardware running on slightly newer hardware?

The software is running on an entirely different platform with different priorities. Security being the main one.

The only significant difference in priorities as regards speed would be the modern prioritization of "developer time", ads, and telemetry.

I can run Windows 95 applications at better than era-appropriate speed, in an x86 emulator written in javascript running on a web browser. That's at least 3 layers of virtual machine abstraction and the applications are still faster.

So if you're saying "the comparison isn't fair because modern software is too shit to hold up", then I agree, but if you're trying to tell me there is something else inherent to modern computing that makes software so many orders of magnitude slower, than I request that you show data to support that claim.

Running Windows 10 on hardware with a larger gap in time doesn't match the benefits you see in this video. It's just slower.

I am always frustrated with the usual answer to these kinds of demonstrations: “Yes, but these new apps are doing so much more. Also, security.”

Except, that they are not, not at the time they are launched at least. And even if they were, we have a hundred-fold more compute power, with a hundredth of the latency for memory and storage.

Regarding security, it should have negligible effect in most cases. At least, effects should not be perceptible to the human mind.

It really is just a consequence of the way we develop software nowadays. We do not need to optimize programs to make them work at all, so we just do not. We work on new features, and we hire people who can churn new features.

And we decided to optimize for developer time, instead of user time. So, instead of painstakingly developing a Web site, a native application, an Android app, and an iOS app, we just push Web apps everywhere.

> And we decided to optimize for developer time, instead of user time

That’s exactly it, and there’s no shame in that. I can, as a solo developer, build a fully featured app with a responsive UI and produce artifacts that run on Windows, Linux, and Mac. I can do that in a weekend, because of the technologies we have at our disposal. Something that would have taken a team of developers several months to do.

On the other hand, the fact that we’re abstracting everything except the business logic away is a big advantage. As soon as Chrome pushes a performance update we can see apps across the board performing 10% faster.

And when computers will be 30% faster in a couple years, vs. multiplying the developer time/cost it's a trade off.

What the hardware gives, the developer takes away. Developers will get computers 30% faster, then release 30% slower software, in a never ending cycle.

Right now, an M1 is pretty fast, but wait until all developers use it and it starts to become barely adequate.

Rephrasing Wirth's law: It takes slow hardware to develop fast software.

> Except, that they are not

My experiences with NixOS show me that they are. What do I mean by that? I am forced (MSFT Intune) to use Ubuntu for work, and was using MacOS prior to that. Both took a good heft of time to boot up, especially compared to the WinNT example. They are general purpose and come with everything under the sun installed in-case the user needs it. In the latter case (MacOS) your hands are also pretty tied when it comes to slimming it down (to be clear, apps are easy to remove, but not system cruft).

The slowest parts of bootup on my personal PC (NixOS) are POST and the GRUB timeout. NixOS takes less time than either (< 2 seconds). I chalk that up to NixOS installing very little more than I tell it to.

I agree that WebApps make situation significantly worse, but the OS itself is full of garbage that does eat CPU cycles and IOPs.

> Except, that they are not,

What a weird claim. If the new apps aren’t doing anything more, then just use the old apps.

Except you’ll quickly find that the old apps are quite simple and limited relative to what we have today.

I think the point is that they are not doing much more relative to the hardware improvements. How much less functional was windows 3.1 notepad compared to win10 notepad? 50% (utf8, maybe multiple windows)? RAM and CPU have increased 25000%. That should be way more than enough to handle the extra features in notepad.

> And even if they were, we have a hundred-fold more compute power [...]

This doesn't sound right. Sure, GPUs are probably that much faster, but we certainly don't have the equivalent of a 60,000 MHz CPU.

The clocks have not become a hundred-fold faster, I grant you that. But, combined with specialized instructions, the improvement of the instruction pipeline, the growing cache, the multiplication of shadow registers, the addition of hyperthreading, and the increasing number of cores, we probably do have a hundred time more computing power in a modern laptop.

Wirth's law: https://en.wikipedia.org/wiki/Wirth's_law

See also "input lag" by dan luu: https://danluu.com/input-lag/

It is not the main thing going on in this twitter post, but it does show a way modern computers feel slower than older machines.

I'm of the opinion that the Windows NT family went downhill after Microsoft moved Dave Cutler from running Windows NT development to running other projects (Windows x64, XBox, Azure).

Dave's no excuses attitude towards performance and stability is sorely missed.

I know people who ran Windows Server 2003 as a client OS, which was the last version of NT that Dave was in charge of.

I ran Server 2003 on a Thinkpad T20 as a daily driver. It was a joy to use-- all of the XP kernel enhancements w/o any of the bloat.

If I could, I would use NT 3.51 as my daily driver today. I know a lot of 32 bit software would still work on it well into the late 90s/early 2000s.

The pre-Windows 2000 NT OS's all suffer from needing too many reboots and the whole "re-apply the latest service pack after adding optional components" lunacy.

I'm partial to the Windows 95-style interface so I jumped ship on NT 3.51 as soon as I could for NT 4.0.

Jumping to Windows 2000 was, likewise, an easy decision if only for not having to reboot after making IP address changes, and having USB and plug 'n play support.

Moving frm Windows 2000 to XP was less of a "no brainer". I continued to use Windows 2000 for quite awhile after XP came out. I skipped Vista entirely but Windows 7 was too nice not to jump on immediately. (It was the first MSFT OS I ran as a daily driver in beta, actually.)

I ran windows server 2016/2019 as a development workstation for a couple of years. It was great compared to windows 10. If docker hadn't dropped support for desktop on windows server I might still be running it.

Opening Notepad, a DOS prompt, and Paint do not faithfully represent the app load speed experience on that hardware. Try Microsoft Office, or CorelDraw, etc.

Yup. Meanwhile I can fire up nvim or Gnumeric and they also launch basically instantaneously. Selection bias, it's a thing.

You can open notepad, a terminal prompt, and paint on modern Windows and it will be sluggish.

Word 97 opens instantly on my Pentium MMX 200 Mhz with Windows 98 SE (64MB PC66 SDRAM, 8 GB CF Card running in PIO Mode 4). This is a little faster than my Surface Pro 9 opening Word 365.

It is such a pain to write Win32 code that you didn't have time to add all the features that would slow down program launch.

As cynical as this comment may be, there may be an element of truth to it. If it is time consuming to add a bunch of visual effects and transitions, you aren't likely to spend time doing that if you could instead be adding useful features.

Most software is not developed by a single person and adding animations have very little overlap with most functionality, so it is almost completely parallelizable.

I know you probably meant it in jest but as someone who wrote a bunch of desktop apps at one time, it was actually easier to develop desktop apps in tools like Delphi in the 1990s than it is to develop apps now.

For me, VB6 was the pinnacle of Windows desktop app development. When I first starting building web sites/apps it was such a huge step backwards.

It was/is a huge step backwards in terms of DX, but an infinite step forward for distribution. Distribution is the ONLY problem, which is why the shift happened.

Absolutely, which is why I (we all really) put up with the mess that is/was web development.

Try Xojo Web, pretty neat tool with VB like web builder.

But, Delphi existed mostly because of the terrible default Microsoft DX. Writing pure Win32 was indeed pretty awful (and still is).

Misunderstood or intentionally misapplied "wisdom" like "premature optimisation is the root of all evil".

Programmer comfort, unified frameworks, higher level languages over user experience.

Focus on end users instead of professional users.

Stupider programmers and programming through "good enough", "everyone can code" and "salaries are too high, hire someone cheaper".

Computers getting cheaper, therefore users buying new machines to run software faster, instead of programmers trying to get stuff running fast on current hardware.

Yes, and there is never, ever time to go back and address the weaknesses of the initial fast and dirty approach. If you prove out a product, it's proved, and any further work addressing tech debt is pure overhead, from the perspective of the business. Like so many problems, the ultimate solution is large scale collapse. We are now open to a super-virus that renders all of our (internet connected) compute worthless, or worse. It's a good opportunity to learn a trade, like carpentry, pottery or (pre-2005) auto repair.

As others have pointed out, Windows 2000 would probably be a better comparison than NT 3.51. Apps did not open instantly on most computers in ~2000, and larger apps like Word could take a few seconds.

On the other hand, a large part of the delay was due to the slow seek time of the magnetic hard drive (milliseconds). The CPUs only had one core, and RAM was both smaller and much slower. Modern SSDs make seek time negligible, ancient PassMark scores suggest a >10x improvement in single-core CPU performance, and there's been a >20x improvement in RAM transfer rate and a >40x improvement in RAM size. Residential internet bandwidth has seem something like a 100x improvement.

None of that hardware improvement seems visible in modern PCs, except for nicer graphics and (especially) higher-resolution displays. But comparing video games from ~2000 to video games today reveals just how small that graphical difference is in the OS/application space. MS Office was a lot more responsive in the early 2000s, too.

In the early days of Firefox, the developers bragged that every new release was smaller than the previous one. Maybe one day there will be a fad for more responsive software in general.

He already did.

If you scroll down a little bit, he demos Windows 2000 on the same machine. https://twitter.com/jmmv/status/1672073678102872065

Because we cannot accept a certain piece of software as finished. It doesn't mean there aren't any updates. However, in the iOS store I can update some apps every week.

On the other hand, I very much like the F-Droid store. There are so many useful and user-friendly apps. They work and stay like this for a long time.

I suspect the underlying topic here is money. Open source apps don't get much funding. So the developers need to focus on the essentials and get them right. On the other hand, subscription-based apps have a steady inflow of money. For some reason, they need to constantly work on these and add new features with marginal utility. I regret having updated some iOS apps. They were working perfectly fine in 2018 but have added bloat and bugs since then.

I have a related issue to report: high power usage at idle(or should I say: no user interaction).

In the past it was understandable, because those primitive 130nm, single-core CPUs had to keep spinning since performance scaling was still a relatively new thing back then.

Despite all the advancements in the field it seems like more often than not each of those cores is up to something at all times.

First thing I do with a new Android device is to limit the number of background processes. This causes occasional crashes of some apps, but the difference in general smoothness is noticeable.

Meanwhile my laptop draws 30W seemingly doing nothing in particular.

Launching HWiNFO halves that number which, if actually true, is properly insane.

I think this is one area where long-standing assumptions underlying key architecture decisions are no longer true. Another one would be security, which is laughable in the desktop space.

Reminds me of finding an old laptop in the attic (IBM ThinkPad 760LD). 90MHz Pentium, 8MB of RAM, 810MB of HDD, with Win98 installed. I could boot it and start Excel 4 times in the time it took for my workstation to even get to the desktop. Really nice and snappy usage experience.

Sidenote, look up the ThinkPad 760 series, it had some really cool features. Raise-able keyboard so you could have it at an angle, physical sliders for sound and backlight, easy access to the internals and hot-swappable battery.

thinkpad 760xl here, svga+ screen, 166mhz pentium mmx, 64mb of ram, 2.1gb hdd, typically use it as a dos machine, tho it does have old slackware linux installed. if you still have the laptop, hold on to it, or if you don't want it, please give it one of the many retro groups who can maintain and keep these things going.

At the speed of light, photons travel about 1 foot per nanosecond.

In other words, a modern 2 GHz processor would have time to execute at least one instruction between the time photons leave the screen, and the moment they reach your retina. Probably more than one, with multicore pipelined processors.

And yet today we wait and wait and wait for Windows to open a simple program.

Indeed... what happened?

Let's assume, 10 milliseconds = 1 CPU year. (If dogs can have their own years, why not CPUs, as well?) So, there you sit, waiting hundreds and hundreds of years…

I already struggle with waiting for the rube goldberg-esque build-deploy-to-dev loop at my current gig. Thanks for the additional disgust.

I hear, the British Heath Robinson version (by Tommy Flowers) was quite fast… ;-)

> At the speed of light, photons travel about 1 foot per nanosecond.

Americans have this disgusting way of embedding their sexual fetish into even the physical constants.

This reminds me of [this](https://www.youtube.com/watch?v=pW-SOdj4Kkk) talk by Jonathan Blow. He compared the startup time of an older and newer version of Photoshop. The newer one was several times slower despite basically being the same program.

Every developer for the past two decades has been banking on Moore to save them from the consequences of poorly written code and importing a boatload of 3rd party dependencies but Moore is running out of funds and the bill is coming due.

That's what happened.

I think you can add a couple of decades to that statement. People were already complaining about poor C code, when you could write "proper" performant code in assembler...

I remember those days, Win 3 was never that snappy. You had to wait and it was really happy to crash if more than a couple of programs were running.

Win9x was better, you could run a few more apps without too many issues. But blue screens were super common. But it was fairly responsive if you didn't have too much running.

Win2000, yeah it could be that responsive.

What stands out to me, is Windows is very responsive the less stuff that is running, even today. Once those older machines had to do anything else you had to wait.

Those old apps sat much closer to the metal. I can't imagine how many layers sit between windows apps today, worse if they off Electron.

I use WinMerge[1] a lot, and it's always impressed me how it immediately opens to a useable state. So it's absolutely still possible to write Windows software that can open instantly. I think the biggest issue, which multiple other comments have identified, is that people just don't care. Apps open fast enough these days, and no one is pushing back on developers to improve their app's startup performance.

[1]: https://winmerge.org

What disgusts me the most is on the modern system every single window either animates in a glitched empty then flickers to redraw properly or animates in an interface but then flashes as it redraws to show what it’s supposed to be.

Resizing makes the windows flicker disgustingly. Even the mouse cursor changing to the resize widget often draws a large glitched cursor for a single frame on every windows machine I’ve used sometimes.

If someone ever fixed this trash and made the OS feel solid and not a flickering glitchy mess I’d be in their debt.

I am currently using Windows 10 LTSC (the newest version) and after some basic configuration it is INSANE how responsive it is. It boots basically instantly and apps launch instantaneously. I hand the laptop to random people and they are always amazed and how well it works. This is on a decently fast Dell XPS laptop but nothing insane. All the crap has been stripped out.

Seriously recommend trying it out - more responsive than any OS I have ever used - even a lean running Ubuntu or OSX

If you think that's responsive you haven't seen my XFCE setup.

I'd like to see it. I'm running XFCE now, I wouldn't call it slow but it's not quite as snappy as I'd like it to be.

Turn off composition (if Xfce allows you to, like KDE does). Then drag a window around your screen on a high framerate monitor and feel the difference.

just tried it, gives nasty looking black bars around the outside of firefox.

latency is still there. e.g. pressing super has about a 100ms wait before the application launcher appears, same as with compositing on.

I think GTK has a setting on setting up the menu spawning speed.

Also, if you can, for desktop worloads, switch to the xanmod kernel.

Electron is probably the biggest culprit. There are still a few native apps that I use like mIRC, foobar2000 and they always feel very snappy.

Electron feels snappy on modern machines as well. If only it took a bit less RAM than it currently takes to run an app.

I read somewhere that Webkit and specifically Chrome are optimized towards more efficient CPU usage in the expense of a larger RAM use. Probably makes sense in terms of energy consumption but you need more RAM.

And yesterday I was mercilessly downvoted for saying VSCode is slow compared to software from decades ago.

At least you’re getting a lot for that, though I don’t love Electron either. What does notepad.exe of today have over notepad.exe of 25 years ago? UTF-8 I guess. Not sure if find and replace was a thing in the olden days. Better line ending support too. I’m really wracking my brains here to think of stuff

Line numbers came in with XP, I think.

I'll have to agree to disagree. In my experience IDEs are the one type of software that were always slow, Eclipse is two decades old, and it's slowness was on a whole different level.

I guess you never heard of Sublime text?

Visual Studio 6 was very fast even on my PoS machine at the time.

Faster than Jetbrains on an M1. Not used VS for a while but holy shit that crapped the bed in 2002 performance wise.

I remember differently, I remember visual studio 6 bringing my PC to is knees (although to be fair I was a broke student and my PC was a potato).

I upgraded my system less than 24 months ago, up from 8gb to 16gb of RAM. My main reason for that was gaming, but I also expected a speed-up on the usual OS tasks.

A month ago I realized that my RAM was topping at 95% capacity when running the usual suspects (vscode, edge, etc). I bought an additional 16Gb, and I'm already at 55%.

Now, RAM optimizations aside, what the hell...

I blame us, or the current generation of us. Performance (CPU and RAM) is so cheap that I feel we don't optimize anything anymore. Many of my colleagues don't have a clue on how to run a profiler, let alone actually optimize a system.

And we are always turning to more productive yet less performant platforms such as nodejs etc. It's a valuable trade off, but maybe we have gone all to an extreme...

I think a lot of that could be brought back to something closer to resembling immediacy if you go and take the time to remove all the stuff they introduced along with vista (The fadein/fadeout animations especially)

I think you mean "with XP". So bloated, with all that bevelling and shadows and DRM...

Windows 2000 was peak Windows, minus security. Security is miles and miles better today.

Nothing will change my mind about this, ever. It's been downhill since then.

Does Windows 2000 handle native Bluetooth better? What about WiFi SSID management? Does it ship with good IPv6 support?

no, no, and no. Lets see if we can petition Microsoft to add them, and then we'll see if Win2000 still runs decently fast on a P4 with 4gb of ram.

My guess is: yes, it will.

Somehow, in the past 15 years, "progress" seems to include "software keeps getting noticeably worse, but anyone pointing this out has to be shot down because progress."

Ah, there's another question, I'm running 32GB of RAM currently on this machine and 64GB at home. How well does Windows 2000 support >4GB RAM or SMP? Does it come with a good hypervisor? I do like running a lot of VMs in Hyper-V as well.

Sure sounds like there's a ton of gaps in things I really want out of my operating system on Windows 2000...

I think you're right in general but I'll note that Windows 2000 does support PAE (very limited >4GB support on 32-bit) and SMP.

Sure does.

Does the switch to 64 bit slow things down enough to explain what happened between Windows 2000 and XP?

Does the operating system have to support virtual machines? Seems easy enough to install vmware then run operating systems inside it for most use cases.

I mean, you can keep 'what if'ing me here, but, is it really worth having all the features that you, clearly as a power user or professional, use installed on every computer everywhere? No. No it really doesn't. It's bloat.

> Seems easy enough to install vmware then run operating systems inside it for most use cases.

That's a way different experience than running Hyper-V.

> is it really worth having all the features that you, clearly as a power user or professional, use installed on every computer everywhere? No. No it really doesn't. It's bloat.

I also didn't realize that managing WiFi networks or using display scaling are things only power users and professionals would want on their machines. I guess supporting Bluetooth natively in the OS and a modern sound stack is just bloat for most people.

so, I can't reply to your latest message because it's too far down but...

Let me just hop on my wifi and browse the web. Lets do it on a computer from 1999. 2000. 2001. 2002. 2003. 2004. 2005. 2006. 2007. 2008... etc, etc.

Why is it that every couple years from 2012 onwards, doing the same thing keeps taking longer, even with new hardware, without the same revolutions in quality and experience that came with that new software previously?

Your 1999 computer supports WPA-2 out of the box? TLS 1.3?

> doing the same thing keeps taking longer

But I'm not doing the same things anymore. I'm doing a lot more. Things that aren't supported in that 1999 OS at all.

... you completely missed the relevant part with the "1999" part. The relevant part is the "2012" part. Things used to get better, do more, and faster. The last 15 years, the "do more" part has been less and less useful, and the "faster" part has turned into "slower" in a number of ways. Software engineers are relying on an increase in hardware performance to pick up their slack, and that line is running out quickly, and there will be many years ahead where we're cleaning up over a decade of laziness.

> Things used to get better, do more, and faster.

I bought a newer PC because my older one from 2012 legit wasn't fast enough for what I wanted to do. It couldn't handle the VR applications I wanted to run, as its PCIe and RAM performance just wouldn't be up to the task to run the resolutions, texture qualities, and latencies I wanted. The newer one is miles ahead of the older hardware, and the applications I use are significantly better because of it.

But even then, from the other perspective of continuing to run similar-ish workloads using newer software, a lot of the other things continue to run the same experience-wise with slightly better features than when the software was new. When I first built that 2012 machine I installed the then brand-new Windows 8 on it. These days its running Windows 10. From a UX perspective it definitely feels faster than the OS it shipped with. Things like the new Terminal app are way better functionally than the old cmd.exe that used to be on it. I do demand more still from using VSCode with more plugins and what not than before while previously I used things like PyCharm more. I videochat, watch more streaming content on it than when I first had it, and it consumes far more animated GIFs and what not than it used to.

But in the end even with software supposedly getting more bloated and what not, its at least as snappy if not more than it was when it was brand new in 2012, other than the fact there's a whole new class of application I demand from my hardware.

So yeah, even today things are still getting better, doing more, and getting faster. Its not the extreme doubling or quadrupling of stuff like the 80s and 90s where things literally went from only text interfaces to GUIs to 3D apps, but there's still bleeding edge stuff that legit just takes more oomph than a box from 2012.

There's been a problem of lateral rather than forward progress in nearly all industries since the early 2000s. Lateral progress being a different way to do the same exact thing (a doorknob versus a lever latch for example), and forward progress being a new way to do a similar thing but in a much more efficient and modular way.

It's been bothering me for some time ever since I noticed it with the advent of IoT "smart" devices that have the same features as traditional appliances for twice the cost and technical debt. My washing machine still washes clothes and turns itself off, but now I need to set the wash type using my phone because lateral progress dictates a physical interface on the device itself is obsolete.

I used windows 2000 for many, many years. Pretty sure until 7 came out.

They're loading the toy applications that came with Windows 3.51 an operating system developed when 486's were common and first generation Pentiums were the bleeding edge, so around 100 MHz. (Also, using clock speed alone discounts any generational bumps in efficiency.) Of course it will be fast.

The same apps were opened on his modern machine for comparison. Are windows explorer, notepad and command prompt toy apps?

> Are windows explorer, notepad and command prompt toy apps?

Yes.

Please don't take my excuses the wrong way, since I wish the performance in software reflected the increased performance of hardware, but we are comparing the performance of an operating system released five years prior to the CPU it is being run on to the performance of an operating system contemporary to the CPU. A couple of other things to note: the comparison uses a bleeding edge Intel processor for Windows NT and, to try to be polite about it, a processor optimized for energy efficiency for Windows 11. (If the tests depended upon CPU performance alone, the benchmarks for processor in the Surface Go 2 are comparable to my 11 year old i5 3330. That i5 wasn't even a high end processor at the time.) The second thing to consider is that performance gains were much more dramatic back then, so even if we could test Windows 11 on a 2026 processor, I wouldn't expect such dramatic results.

Windows 95 running on a 133mhz computer would open Excel (I believe from Office 98) essentially instantly once the machine was up and running. Which unless you had AV running took under a minute.

Modern OSes have the technology to make even the calculator app load slowly https://bugs.launchpad.net/ubuntu/+source/gnome-calculator/+...

I checked if I do have Calculator on my Debian and I found it. It opened instantly. However that was an issue for Ubuntu and was fixed in 20.04, three years ago.

By the way, I do my math with bc -l from the command line.

I recently watched a junior dev casually add this hideously bloated and slow library so he could save an hour or so of programming. Part of his reasoning was that "everybody else does it that way".

And that's why modern hardware keeps getting faster while modern software stays the same speed (or slower).

I'm very curious which library it was

The next generation of devs became focused on their tools. Explosion of programming languages and frameworks. Cloud and all its vendor lock in. Agile. CI/CD pipelines. K8. Constant re-invention of the wheel just because. Lunatics are running the asylum. It's embarrassing, frankly.

I'll share a memory circa 2010 from my time at BlackBerry that comes to mind when people point out performance problems like this.

Around that time, whenever a new BlackBerry device was rebooted, it would take about 45 seconds for the OS to fully boot and become usable. I'm making up the actual times in this story because I can't remember the exact details now. Like in this video, the oldest devices would start up nearly instantly, but the boot sequence for modern devices was agonizing. Especially when you were an engineer trying to run a test that required rebooting the device!

One day, a pair of engineers finally became annoyed and curious enough to look into it and profile the problem. They found that a substantial portion of the boot time was spent parsing XML files that contained descriptions for device themes - that is, information about colors, icons, and text styles that users could choose from to customize their device. Something like a full 15 seconds was spent just on this one feature as part of the boot sequence!

So what happened? I suppose that no other engineers felt they had the responsibility or the time available to look into the long boot times until that point. But imagine being an engineer at a company like Microsoft, and one day saying to your manager or product manager: "Hey, can I spend a week on understanding why it takes a full second for Terminal to boot on Windows and see if we can speed that up?" How many managers are going to be enthusiastic about that when they're staring down a kanban board with enough tasks to fill 4 quarters?

The only reason these engineers at BlackBerry were able to look into the bootup times was because they didn't have to answer to anyone responsible for product. The team lead for this team at the time was "Engineer #2" at BlackBerry who had written all the apps for the first devices. His team was given permission to pursue whatever ideas or prototypes interested them, so they had the breathing room to chase leads like this that wouldn't necessarily pay off.

So part of the answer is that I don't think we as an industry are prioritizing performance. Once the performance is good enough, it's time to ship and move on to the next feature. But the other side is that we're building in more dynamic behaviour to our software. More customization, more flexibility, more behaviour that's defined at run-time. And this all probably makes software more useful and makes it easier for engineers to build more complex software. I think it's a similar kind of trade-off to choosing between python or Rust for a tool you're working on. What kind of performance do you need, and what kind of developer experience do you want?

Wait’ll you hear about changing TV channels in 1985.

'What is a TV channel?' (said by my daughter to me recently)

Wait’ll you hear about changing TV channels in 1985.

Turning on a TV in 1975: wait 60 seconds for the tube to warm up.

Turning on a TV in 1985: wait 10 seconds for the tube to warm up.

Turning on a TV in 1995: wait 2 seconds for the tube to warm up.

Turning on a TV in 2023: stare at the LG logo for 20 seconds, then wait another 30 seconds "for Smart Services to become available" in order to change the channel.

Or for my nearly brand new Samsung smart TV - starts up in about 5 seconds, then you can happily watch TV and I did for a few months until it forced an update, which slowed things down.

Now things still work, but the TV needs a restart about once a week if I use the built in apps like YouTube or Netflix.

Finally bought an Apple TV 4K and it "boots" directly into it. Such a relief! (Well, except for that bizarre touch remote that came with the Apple TV, but that's a small price to pay!)

It's asinine how slow service provider's boxes work nowadays. Our Xfinity cable box has a .5-1.0 input lag, (more like 2secs for ff/rw/play) and it's the same even after customer service replaced it with another unit. What a waste of resources...

Back in the day I had a Windows NT 3.51 machine sitting on my desk, right next to a HP 9000 workstation (PA-RISC) running HP-UX; I do not remember the NT machine being this responsive. It wasn't terrible but I did most of my work on the 9000 because it felt faster than the NT machine.

I wonder if the 600MHz machine in this video is fitted with an SSD of some sort, this would load applications far faster than the average hard drive from 1998.

You might be onto something. As P3 class hardware started to age, IDE to CompactFlash adapters came on the market as an option to replace aging mechanical hard drives.

Eh... a bit inaccurate, I think.

First, he's probably running those OSes on a monster of a machine, relatively speaking. Stuff is snappy on my desktop too, which has a PCIe4 NVMe drive and 128 GB RAM. Chromium, which is a huge and very complex application starts up in maybe a second or less.

When you're doing old school computing today it's easy to max out the specs to a point that would be unrealistic in that time. You can put 128MB RAM into a machine when most people in the day might have had 16MB. NT4 is from 1996, and that machine is from 2000, so seems likely. I remember computers back in the day. Windows 2000 ran slowly on the hardware I had.

Second, modern software does way more in the name of convenience. Eg, nobody really uses notepad. We use VS Code for instance, which is an enormous application, the sort that would have seriously challenged a computer back then.

And really everything grew in the same manner. Discord is big, but Discord draws its own widgets and includes a web browser. If you did Discord with native widgets, plain text and without all the fancy stuff like animated emoji and special effects, it'd be much lighter and faster to start too.

> very complex application starts up in maybe a second or less

nailed it.

a second is a very long (noticeable) time and as a user i don't really care, i want it fast and consistent.

And very short for a big thing you load once.

Back in the day plenty things like Photoshop had splash screens, and you got to stare at them for quite a while.

Except we're not talking about loading something big like Photoshop. We're talking about starting the modern versions of system Notepad or Calculator.

The big stuff like Photoshop loads roughly as long as it did before. This is a good indicator of how bad most software is - if applications like Photoshop followed the same performance/feature curve, they'd take hours to start.

I was talking about Chromium starting in a second or less. That's the open version of Google Chrome. It's a big application by any reasonable standard, and not something you start often either.

Just strip out the tracking use alicord. Or for true native speed ripcord

I would never use Windows again for my own computer. It loads shit like candy crush in the background and keeps it in memory 24/7. You cannot disable that. Candy crush… I don’t know how people work at microsoft unironically.

Compare that to Mint which looks exactly the same as Windows and now runs 100% of Windows games and it’s just unfair. It’s like running candy crush in a barrel.

Good question.

Linux also opens apps instantly, at least for me and if you ignore that some app after being opened instantly don't get instantly ready to work.

But that isn't fault of the OS.

Through some OSes used some tricks to hide this loading time.

A good example is cold starting a web browser. Modern web browsers have to handle so much that just loading the amount of code they have all at once can lead to a noticeable delay. I mean e.g. the network code your browser runs is likely a few hounded to thousand times more complicated then what you put into a simple HTTP server. There is also the rule of thumb that the difference between something working in your use-case and it working in as many situations as possible for as many people as possible might look small from an external POV but in general comes with an explosion in complexity and code. And for browsers that is not just the case for networking but also rendering HTML+CSS, executing JS, storage handling, window handling, handling boundaries and security, extensions, caching, input handling etc.

In France in conforama stores salesman use a ascii terminal GUI connected to AIX shells. Fast as hell to take your order. I’m always amazed at how marketing BS lead us to vastly sub optimal solution.

New software is written cheap. I know what you think, when you hear it, but it's much cheaper to create some functionalities that backdays. We have c# in Windows and Java on servers. This is an abstraction layer which makes things working very slow. We have JavaScript applications each running in it's own Electron sandbox. This is huge help and huge cost of performance. And it's a huge help for developer. Entry level is much lower, one does not need winapi anymore (at least in most cases), animations, rendering, typesafety for free, no coredumps, no segfaults, no guru meditation. It's different world now. And a single hello world application weights 200MB...

And another thing: security. Security on old Windows was poor. There are many things that need to be taken care of, but they used to not exist or were simply unsafe. This is another thing, one need to keep in mind, if one wants to just install windows 7 or XP and play games (as I did)

Why would C# or Java make things “very slow”? The code ends up running as well-optimized machine code for the majority of its lifetime.

Ends up is the keyword here. Virtual machine takes time to start and warm up. There is an indirection layer between CPU commands and c# bytecode. Of course programmers stronger than me and you (maybe not you? But me for sure) are working constantly on how to improve this, how to make just in time translations etc. But These things take time. Native is faster on startup. Later java/c# wins unless the native code is done by a very skillful programmer. we're speaking on app startup time, right?

Also blame OS vendors refusal to standardize on the graphical GUI equivalent of stdio/ascii. All I want is bare-minimal GUI support (pixel placement and "pointer" events. That's all.

Instead we get apple, google, microsoft, and gnome/qt all doing their incompatible thing.

So until they do, expect the beatings to continue. /shrugs

Same with MacOS 10.6.x

Snow leopard with a intel dual core 4 gigs of ram and a SSD performs as well as a MacBook 2019 i7 running 11.x Monterrey.

So much unnecessary processes in the background IMO

Keep it simple stupid whenever possible

Simple answer: It's abstractions all the way down.

With an old machine, you can feel the "slowness" doing a similar test with something coded in assembly vs compiled.

The reality is, to be fast, do less.

Abstraction is maybe the incidental reason start up is slow but the real reason is because no one cares.

You don't toggle apps open and closed so an initial wait to load up more features just isn't a priority.

There's always a brief window in time with any new technology where it's new enough that the suits haven't entirely gotten their hooks into it, so it's broadly made to be as effective as possible at doing what it's supposed to do. We unfortunately now live well down the enshitification curve of computing and now most everything is made not simply to be as good as possible at it's intended purpose, but rather to make the companies that make it is as much money as possible while performing it's intender purpose at whatever minimum standard will annoy users ever so slightly less than the amount it would require them to stop paying money for it.

Apps got a lot larger?

Also they added desktop compositing animations.

Opening a command prompt or mspaint is not exactly demanding and opens instantly on modern computers too when all desktop compositing animations are turned off.

>Apps got a lot larger?

This guy is also comparing old HDD to SSD, RAM speed is also magnitudes faster

Instantly? Are we watching the same video? Have you not used any version of Windows past 2000? It took well over a second for explorer to open (and even longer to load) on the modern laptop; It even took over a second for the terminal to load. Having native programs open in under a frame on modern hardware would be trivial just ask the kernel team to write the application software.

I literally just tested it on my Win10 PC and it's instant (I have all compositing animations turned off).

There was a marked difference between Windows 2000 and XP.

Windows 2000: Everything opens instantly, no delays. Felt nice.

Windows XP: Noticably more sluggish than Windows 2000.

They've never recovered.

How much of that latency is down to DWM (the compositor) doing fancy transitions? It seems like there's at least a 1/4 second dedicated to the grow/fade in.

If you search the startmenu for "advanced system settings" it will pull up a control panel era System Properties app with an Advanced > Performance option. Turning off visual effects there dramatically increases responsiveness.

I'd love to see it booting and then cold starting the apps, for comparison.

Software is slow because being slow isn't fatal.

600 mhz is quite the machine for NT. I remember running NT4 on a 233 mhz pentium II with 128 MB RAM and everything felt instant and limitless.

Windows 2000 was quite the hog compared to NT4 and all it added that I had a use for was USB support. I think by that point Dave Cutler was no longer running the show and windows performance slowly started degrading.

He shows Win 2000 later in that thread, still snappy.

I remember a HP machine (@600Mhz) which my company bought circa 2001 that came with an install CD that had both NT 4.00 and Windows 2000 and the user could decide to install the one or the other, a few machines had initially NT 4.00 due to some accounting software that did not run (for whatever reasons) on Windows 2000, while some had 2K installed.

Of course the NT 4.0 was a bit faster, but not that much with "common" programs (Office and similar).

The occupation on disk of the OS was however 3x (NT 4.00 was around 180 MB, 2K around 650 MB).

I think, the most important factor isn't so much the CPU, but loading binaries from disk. And that (I/O) improved quite massively over the 1990s. (And anything written for spinning disks will start nearly instantly using solid state storage.)

To illustrate the CPU/disk-access ratio: There's a reason for scripting languages becoming prevalent for web backends in the 1990s. Loading a script source from disk and precompiling it on the fly was still faster than loading a much bigger binary from disk – which had to be done on each CGI request. (E.g., with Perl, you could have your normal script, but you could also produce an executable binary from a core. But nobody did the latter for the exact reason.)

Completely agree with the key point here. An example that blows my mind is the incredibly unresponsive UI built in to my $2,000 television. How does a very expensive device like that end up with a series of clickable boxes that lag so much I frequently wonder if it’s working or not.

For those who were not around, or forgot: A fresh install was indeed glorious. Fast, clean, snappy, but everything invariably slowed down to a crawl within a few months and you had to reinstall and reformat about once a year go get your shit under control because it became unbearable.

Hey folks, author of the Twitter thread here.

It's pretty funny how a pair of crappy videos I recorded in 5 minutes have gone viral and landed here. I obviously did not expect that this would happen and is why I didn't give a second thought to the comparison. There are many wrong things in there (including inaccuracies, as some have reported), and Twitter really doesn't give room to nuance. (Plus my notifications are now unusable so I can't even reply where necessary.)

I don't want to defend the "computers of 20 years ago" because they sucked in many aspects. Things have indeed gotten better in many ways: faster I/O, better graphics and insanely fast networks are a few of them, which have allowed many new types of apps to surface. Better languages and the pervasiveness of virtual machines have also allowed for new types of development and deployment environments, which can make things safer. Faster CPUs do enable things we couldn't do, like on-the-fly video transcoding and the like. The existence of GPUs gives us graphics animations for free. And the list goes on.

BUT. That still doesn't mean everything is better. UIs have generally gotten slower as you can see. There is visible lag even in fast computers: I noticed it on a ~2021 Z4 workstation I had at work, I noticed it on an i7 Surface Laptop 3 I had, and I still notice it on the Mac Pro I'm running Windows 11 on (my primary machine). It's mind-blowing to me that we need super-fast multi-core systems and GBs of RAM to approach, but not reach, the responsiveness we used to have in native desktop apps before. And this is really my pet peeve and what prompted the tweets.

Other random thoughts:

* Some massive wins we got in the past, like the switch from HDDs to SSDs, have been eaten away and now SSDs are a requirement.

* Lag is less visible on macOS and Linux desktops as they still feature mostly-native apps (unscientific claim as well).

* The Surface Go 2 isn't a very performant machine indeed, but note it ships with Windows 11 and the lag exists out of the box, so that makes it enough to qualify as a fair comparison. The specs I quoted were wrong though because I misread them from whichever website returned them to me. I don't care though because this is the experience I get on all reasonably-modern machines.

* Yes, I had opened the apps in both computers before running the video, so they were all cached in memory (which puts the newer system in a worse light?).

* One specific thing that illustrates the problem is Notepad: the app was recently "rewritten" (can't recall exactly what the changes were). It used to open instantaneously on the Go 2, but not any more.

* NT 3.51 wasn't truly fair game because it was years-older than the machine. But if you scroll down the thread you'll see the same "test" rerun on Windows 2000 (released same year as the hardware).

I might come back to extend the list of random thoughts. A proper follow-up blog post would be nice, but I'm not going to have time to write one right away.

No one could seriously disagree with your findings. Your modern windows box is probably phoning home before opening each app, among other insane behaviors.

Windows 2000 (Server) was the best windows operating system ever made by far.

Agreed. OS design (at least as far as the user experience) peaked with windows 2000.

Hey, thanks for the write-up. I've been losing my patience with Windows for a long time, and seeing "AI" in an add on my start menu made me see red. I downloaded Linux Mint on my laptop for the first time and have been tinkering around with it for the past few days - it's definitely got a learning curve, but I really appreciate how flexible it feels versus Windows. I'm one of those people who have to go into Powershell with any new Windows device right off the bat, so I can remove most of the apps I don't need - an Xbox game interface, really? - but even I can remember a time when it wasn't this bad. I'm not even that old: the earliest Windows system I have concrete memories of is Windows XP!

But, like, I literally want to know why this is happening on a technical level. Notepad is Notepad. What the heck is it doing that makes it take so much longer? What would it take to get back to this level of responsiveness on a machine which has, let's say, 2gb of memory and an Intel atom chip, which is still a heck of a lot more than that NT machine was running on.

layers upon layers of abstraction. Windows testing every single application in case it needs to drop down to 32 bit or windows 95 compat. Security checking, telemetry, theming, spinning up GPU to draw what you see.

Because nowadays notepad is unfortunately a "Packaged Application" (UWP), and starting a Packaged Application involves a ton of system components (IIRC relies on an Activation Manager to make RPC and DCOM calls, create an AppContainer and various tokens, to, maybe, if you are lucky, spawn a process). There are more details about this in Windows Internals 7th, Part 2.

But it's not like this is limited to Windows. I'd guess that if you tried to open TextEdit on an extremely old and low-end Intel Mac (which again is still an order of magnitude faster than computers 20 years ago which could edit text just fine), the app would take a while to launch. And it probably wouldn't be a great experience.

I haven't used desktop Linux recently, but my expectation would be that e.g. gnome is a little better than Windows and macOS, but still not great compared to what we had 20 years ago.

So there's just something broadly bloated about modern software. And, sure, people largely don't notice because modern hardware is so damn fast, but we're also forcing users to buy hardware that is much faster than what they should need.

GP points out that faster CPUs allow us to do things that weren't possible in the old days, like real-time video transcoding, and I agree that's great! But if you just need to check your damn email, you should be able to save a great deal of money with a machine that's laughably underpowered by "modern" standards, while still checking your email at the speed of light.

What is all this software doing? I guess we're e.g. rendering at higher resolutions than we used to, but isn't the GPU supposed to take care of that?

Abstraction abstraction abstraction abstraction abstraction abstraction abstraction abstraction manager factory impl mushroom.

Developers are falling victim to the same illness that pervades our whole economy: ignoring the ground truth. When Tesla announces a cybertruck it's not because Elon is thinking of selling cybertrucks. It's because he increases the stock price. When developers develop they're developing to fulfil buzzword checklists and not to tell the CPU what to do to accomplish a goal - that's seen as secondary.

Your video is good, something I can link to now when I rant about this to people. Once I got an SSD for Windows 7, everything opened instantly. I'd click Word or Firefox, 500ms later it was open. Loved using my thinkpad E420 with an SSD upgrade and having everything respond instantly while I was studying.

Once Windows 8.0 came out, everything went to shit. It takes several seconds to open anything now.

I recently fired up a Windows 7 VM to interface with some old hardware, and was shocked that everything within the VM opening instantly, exactly how I remembered it.

P.S. The lag is still present on my m1 mac in macOS compared with Windows 7 + SSD. It's a lot better on my Manjaro Linux desktop with KDE, but not quite as instantaneous as Windows 7 was.

I remember when I was asking people why my computer was slow with a HDD as it was not slow before. People got annoyed with my question (and told I did not have the knowledge), it was a weird experience I will never forget.

NEVER FORGET Wirth's Law:

https://en.wikipedia.org/wiki/Wirth's_law

> Wirth's law is an adage on computer performance which states that software is getting slower more rapidly than hardware is becoming faster.

My main suspicion is that OS have some kind of agreement with hardware vendors under the excuse of "it's new innovation which requires more CPU power". It's a hand in hand system where you need new software for the new hardware AND VICE VERSA.

It is veeeery hard to prove it, but it's similar to house appliances using designs and parts that wear out easily. Capitalism and growth DICTATES that it must sell, so it's impossible for a company to survive if it produces durable stuff. It's economically impossible to compete.

It's how the whole industry works (part manufacturing, etc), so it's not possible for a company to go against it. Capitalism cannot allow it.

It's not a cabal, it's just multi-sided stupidity.

*freshly installed OS Windows OS doesn't know how to clean up after itself. after few years it becomes slow.

Yep. I used to run NT 4 on a P3 550 with 128MB of Ram with an Adaptec 80MB/s SCSI hard disk and A Matrox Millennium video card. Adobe apps even launched almost instantly. Browsing the web with Netscape on our University LAN was super fast too.

When I was running a windows machine, I kept reinstalling MS Office 2000. Why? It was snappy and did everything I need it to do. MS Office is now a 2GB install, when 20 years ago it was 100MB.

Of course there are plenty of new features, but I don't use them.

People bring up cruft and lack of optimization, but leave out the user demand for features.

Did notepad and command prompt really get that many more features?

Command prompt (now Terminal)? Yes, tons. A massive amount of new features really.

Notepad? Kind of. Newer UI library so it handles display scaling a lot better. Handles different line endings and encodings much better now. Handles the system UI dark mode. The interface supports tabs.

>Command prompt (now Terminal)? Yes, tons. A massive amount of new features really.

Can you name a few that could explain the 1,000x performance cost?

Also, have you heard the story about the guy who told MS that their terminal was shit and could be fixed, only to be ridiculed by a fleet of "super elite 500k/year engineers" that in the end turned out to be ... wrong?

Display scaling support

Tabbed interface

Support for command interpreters other than just CMD

Multiple profiles for different interpreters and settings

Support for a much wider range of console control characters and terminal emulations (ssh'ing into linux boxes works really well)

Way better resizing support

Clickable URL detection

More (and customizable) keyboard shortcuts

Support for background images

Support for transparency

Configurations as easy to transfer JSON files

Copying text is a way better experience

Just a few of the features that I use all the time. I can't stand using cmd.exe anymore, its an absolutely miserable experience in comparison.

Unfortunately, none of these are responsible for the startup delay. Since version 1.18 effectively ~90% of the startup duration is spent starting up WinUI and having it draw the tab bar and window frame. It still needs a second to start. If it still used GDI like Windows NT did, it would start in well under 100ms even on an extremely old CPU.

Fixing this situation is essentially impossible because it requires rewriting almost everything that modern Windows is built on. Someone else in this thread said you couldn't sell 4 quarters worth of work to fix this, but the reality is that it requires infinite quarters, because it requires throwing away the last 10 years of Windows shell and UI work and that will never happen. You could paper over it by applying performance spotfixes here and there, but it'll never go back to how it could be that way. At a minimum, you'd essentially have to throw away WinRT which has an almost viral negative impact on performance. Never before have high latency, but still synchronous cross process RPCs been that prevalent and everything's a heap allocated object, even if it's within the same binary. It's JuniorFootgunRT.

> none of these are responsible for the startup delay

> effectively ~90% of the startup duration is spent starting up WinUI and having it draw the tab bar and window frame

I listed "Display scaling support", "Tabbed interface", and "transparency". Is none of that related to WinUI and drawing the tab bar?

Yeah, you're right, they're related to WinUI. But what I meant is that such features aren't inherently expensive, they're just made expensive due to the choice of UI framework.

Display scaling is very fast in GDI apps and has no impact on launch time, a tab bar is essentially just an array of buttons (minimal impact on launch time?) and transparency is a virtually cost-free feature coming from DWM. I wrote a WinUI lookalike using its underlying technology (Direct2D and DirectComposition) directly one time and that results in an application that starts up within ~10ms of CPU time on my laptop, quite unlike the 450ms I'm seeing for WinUI. That is including UIA, localization and auto-layout support.

>Just a few of the features that I use all the time.

O RLY?

Do you have a transparent terminal with a background image? (If so, well ... to each its own :^))

Do you transfer your JSON config files "all the time"?

>Copying text is a way better experience

It literally is Ctrl-C and it's been like that for ages. When did it become a "way better experience"? I missed that.

Modern UX is absolute trash performance-wise. And you're falling into the same pit as the geniuses of the story I mentioned before.

I do keep my config backed up and synced between my computers. It doesn't change that much but it's nice having it easily synced across my many machines when I do make a change.

And no, copying text hasn't been Ctrl+c. That sequence sends a sigint to the process, not a copy request. To copy text by default cmd made you enter a mark mode which then had you essentially draw a rectangle and it would then copy as newline characters even when it should have just continued the line. The old copying process of cmd is terrible.

That could be done under URxvt and a 486 or a Pentium with 100x less resources.

I’ve been using a command interpreter other than cmd for over 20 years.

My old Windows 98SE box on a 200Mhz MMX processor was perfect responsiveness.

We say that today, and remember the best part of the experience... but we do forget, it was all at the mercy of your (maybe if you're lucky) UltraATA/33mhz bus.

It's cheaper to beef up the hardware than to fine-tune the software. Fine-tuning may be excruciating because it hinders all other activities related to the software development.

This isn't exactly a fair comparison. When Windows 3.1 was released, that machine would have seemed like an absolute monster. (Remember when Moore's Law actually got us speed improvements, not just more cores?)

Regardless, to answer "what happened?", people started demanding more from apps (dark mode, UI parity with web editions, rapid prototyping, simple development, cross-platform) and it became cheaper to use Electron (or Qt, or WinForms) than simple win32 calls.

"Dark Mode" isn't a resource hog. Even back in Windows 3.1, you could customize the colors. Hot Dog Stand anyone?

There should be a CSS framework for Hot Dog Stand. Such a marvel!

Screenshot: https://blog.codinghorror.com/content/images/uploads/2005/07...

What happened? Ads, surveillance, virus scanners. And webshit.

This wasn’t my experience back in ~2002 running my Windows NT variant of choice, Windows 2000.

Especially due to the mechanical disk, everything seemed to take 2 to 10 times longer than it does today the first time it had to be done after a reboot, and if physical memory was exhausted and the OS started swapping, forget it, you might be staring at an hour glass for multiple minutes to open a web browser or something of the sort.

I love SSDs and multicore machines of today.

I'd like to see them open Photoshop or something chunky. That's what I recall taking much longer on my G3 Macs than it does on my M1 Pro Macbook.

They should probably run some sort of antivirus too; this is built-in for Windows now, ya? That'd be my first guess for the small programs. My memory of those days doesn't feel any faster than today, but I never had anything as top-of-the-line as a 600Mhz chip in 1999, more like half of that.

I'm convinced that most closed source software made by big companies has sleep() everywhere. Theres just no other explanation. Maybe synchronous animations.

If you get a bonus for improving performance then you’d certainly make sure there are some ready to remove before the next financial year

That OS is five years old when that computer was made.

Here's a much more apt comparison (still really snappy):

https://twitter.com/jmmv/status/1672073678102872065/mediaVie...

Telemetry happened.

Nope. You can turn telemetry off and not see any improvement. Simple reason: your app isn't waiting for telemetry to be sent.

You can not really turn telemetry off, maybe your apps just keep working against you, collecting the info to send after the next system update which use to enable all "disabled" telemetry features.

If anything, doesn't this demonstrate that Windows lacks a sufficient amount of telemetry? If it was sending home stats about how long it takes to draw these windows, and profiles of what the program was doing, then they could target those and make it faster.

I see you're operating under the assumption that the purpose of telemetry is to improve the user experience. I'm not sure that is even a business goal inside Microsoft.

I think due to perverse incentives it causes the exact opposite to happen. Why did the Windows calculator need to be remade with a much slower and less responsive version? Telemetry probably showed the calculator was frequently used, so a Project Manager targeted it for "improvement" and it was then ruined.

I don't know since I never use the Windows Calculator but it seems probable to me that the newer version has improvements that you don't need and therefore do not perceive. Perhaps it is more accessible to the blind, or the support for Urdu numerals is new. A lot of the reasons why old versions of Windows ran apps instantly is that they excluded the entire non-European world and did not even attempt to deal with complex languages.

>A lot of the reasons why old versions of Windows ran apps instantly is that they excluded the entire non-European world and did not even attempt to deal with complex languages.

There was Windows 3.2 in 1994 (not to be confused with "Win32", despite the name of the HTML file): http://toastytech.com/guis/win32.html

Yes the western versions of Windows at the time didn't include support for Chinese (etc.) language. But there is really no reason why they should - if the user's language can be represented in an 8 bit codepage, why should they have to pay any price in performance for something they will never use?

Conversely, would a Chinese-speaking user prefer an operating system designed to support all the other languages that exist, with an implementation that is likely not as specifically tailored to their requirements?

Running notepad is easy. I still shiver remembering running Visual Age for Java as my IDE with Windows 2000. it felt like molasses.

Smart really, they cannot make things too fast or there is no reason for us to upgrade every year to reach that unobtainable top.

Just like the light bulbs: https://youtu.be/j5v8D-alAKE.

With the apps shown - paint, explorer, cmd and notepad, it's still instant today. Web and electron stuff, on the other hand ..

Applications and operating systems can be a lot faster when there is no layered security and everything runs with admin privileges.

Can someone recommend a modern Linux DM/WM and maybe a set of applications which would be as responsive?

I have been running a bare XMonad for a couple of years with `xset r rate 300 40`, and it's okay but far from perfect. The WM seems to process its mouse events with a delay sometimes, and often focuses the wrong window whenever the mouse pointer moves.

I have been a Linux single-booter since at least 15 years, and have used a wide variety of DM/WM as my primaries for years. All my biases are in favour of Linux.

I don't think I've ever had the mouse event delay issues that you're talking about, and I don't use focus-follows-mouse. But I still marvel at how quickly light programs open on all versions of Windows. I mean programs like terminal, notepad, various control panel stuff, MS default games, etc. I don't think you will find anything that runs on X that will be as responsive as Windows. I don't know if the Wayland universe is any better.

Equivalent light apps (e.g., xterm) come up near instantaneously for me. Even Emacs opens in just a few hundred ms.

Back in the day when I was rocking a Pentium, it impressed me how God damn FAST X was. Windows NT (3.51 and 4.0) seemed sluggish in comparison.

Not just that, the transition from spinners to SSD brought a dramatic speed in the OSs of that day but the speed gain has since been rolled back by the garbage layers in the OS. A prime example is macOS which gets slower with each release and it's a tragic level of neglect that there are no mandatory equivalent tests to the last OS release.

In 2000, I would turn on my Pentium MMX 233Mhz machine running Windows 95, and then go and make popcorn while it started up.

I'm curious what's on that system for storage. Is it using the original hard drive, or does he have some kind of solid state medium hooked up? Because I do not recall things loading that fast.

Yes, input latency back then was far better. But actually launching things came with appreciable pauses. Because disks back then _sucked_.

TBF I have been using a Windows 10 machine on a 2017 lenovo laptop for a couple of years and I like the experience. Once I managed to turn off all those widgets Windows 10 brought with it the experience improved a lot.

Of course I'm not using any heavy duty applications, and I only play classic games for which even a Pentium is a bit of overkill.

Network call are incredibly slow compared to a processor call to L1, L2 (damn even L3 cache, an ssd or ram!), so I assume that every telemetry option is putting this computer in a state of "I will waste billions of cycles waiting for an answer from a server for something I could launch right away if I wanted to".

There's pretty clearly a law of conserved latency, that users will gladly suffer x latency for y capability, with capability complexifying until things are too slow, requiring then hw/sw stack upgrades to make it all fast again, while overall capability utilization decreases

That hardware is a few generations ahead of even high-end server hardware when Windows NT 3.51 dropped. Of course, any OS is going to be snappy when running on much faster hardware with much more RAM than it was designed for.

Put Windows 2000 on that thing and see if it runs just as well.

They did exactly that if you scroll a bit down. It's just as fast as Windows NT 3.51.

Windows 11 is doing all these desktop effects (transparency, animations, rounded corners etc) in the compositor. You can disable all those and it will improve things. Also the security related stuff that Windows 11 does is something that was not there in the past.

NEVER FORGET Wirth's Law:

https://en.wikipedia.org/wiki/Wirth's_law

> Wirth's law is an adage on computer performance which states that software is getting slower more rapidly than hardware is becoming faster.

It's how the whole industry works (part manufacturing, etc), so it's not possible for a company to go against it. Capitalism cannot allow it.

Ok, so the NT machine has no opening animations. The W11 machine has opening animations. Those things have a fixed running time. They're used so that the opening isn't so jarring to the eye, but yes, it slows shit waaaay down.

I suspect that these animations make launch feel faster much of the time by hiding the true launch time of the app. And I think this is a primary purpose of launch animations.

Compare to iPhone OS 1: apps had static launch images that the OS animates to be visible so an app has hundreds of milliseconds to load before the user feels a hang.

I recently fired up a windows 7 VM to interface with some old hardware. Everything opens in less than 500ms,just like I remembered it was like once I got an SSD.

Using windows 10+ is infuriating with all the ui latency.

I am using xfce with a minimal set of services and all the system apps and most others open instantly. Alt+tab is also always instant. It is an MS, Apple, Gnome/KDE problem, not modern computers one.

Absolutely, after using xfce for years I find windows very frustrating to use, to the point I can see my colleagues using it and I can see the lag they just think is normal.

Imagine if you work on computers for hours everyday what the cumulative impact is

I just reloaded Big Sur on a 10 year old Macbook (the last OS version it supports), and it runs like that video.

My 2 year old HP laptop running Windows, on the other hand, runs the way we're thinking about.

On my work machine it’s all the ‘helpful’ software IT have added for info sec and asset management and god knows what, they just love to pile this crap on until the machine runs like a dog!

What happened? Apps got huge. OSes got huge. More and more security checks are needed now that every computer is connected 24/7.

But yeah responsiveness does not seem to be a design goal anymore these days.

I agree with the post. My first computer had worse specs than this and was a perfectly usable experience. I actually used it to edit videos. It had 128mb RAM and shipped with Windows 98.

My system pops up a terminal pretty much instantaneously, maybe he just needs to turn off transparency or something? I mean I’m on Linux but I’m sure Windows can be configured somehow…

"the same apps" are not the same. Totally different binaries that load different compiled programs with different features and code and linked libraries.

For contrast, my daily driver is Debian/KDE on a typical 9-year-old laptop and opening/interacting with absolutely everything is immediate and snappy.

Yes, in my experience Linux (at least KDE and xfce) is better at being responsive than recent Windows versions on low end machines.

Where's the sound of the HDD spinning to read the executables? Has he opened them before and are cached or is he using an SSD (would that be possible?)?

Cargo cult happened. 99% of 'improvements' and 'revolutionary new ideas' are hype and horseshit logic.

You could play SNES games with zero loading screens. And it was awesome.

Now, loading screens are everywhere. Like the Atari + cassette era.

I have never worked on modern Mac. Does they have same UI lag as UI in modern Windows or UI on modern Mac reacts instantly?

I used my friend's M1 Air for a bit when it was new, the UI was so fast or almost instant that it felt like a huge leap in general computing power. It also was getting like 20 hours of battery life. That's my only recent experience with macOS on modern hardware though. I otherwise use a 2015 MBPr which is showing its age on current macOS.

Windows has a lot more telemetry and spyware and advertising code in it now that is constantly running. There's probably 10x the number of running processes on a modern Microsoft OS, most of them useless to you.

Also all of the support APIs and libraries for text editing and image display are orders of magnitude more complex now: eg Notepad supports unicode and emoji.

forget Windows NT on a 600Mhz CPU. My Amiga A1200 runs AmigaOS and launch programs from his old rust harddrive, faster that Windows 10 or 11. Everything feels more faster and fluid. And is a machine running at 20MHz with a few megabytes of ram

We all know what happened as programmers. there's layers and layers of abstraction.

Have we tried running the old Windows NT apps on the new Windows system?

Windows NT 3.51 min specs: 25MHz CPU, 16MB memory (for the server edition), 90MB disk space

Windows 11 min specs: 1GHz 64-bit CPU, 4 GB RAM, 64GB disk space.

This is a horribly unfair comparison. We were complaining about systems being slow AF back then too. (Insert _turbo button_ meme here)

That's true, during the time I had a 486 SX 33 with 4 MB and 200 MB HDD. Windows 3.1 ran fine, I tried OS/2 Warp and it was unbearably slow. Never tested Windows 95 on that computer but of course NT was completely out-of-reach. On the other hand "NT" was unusable for anything fun until XP.

Still, there's a point to make about bloat but the comparison seems to be between Apples and Oranges

Windows 2000 used to run lots of games.

Also, you have a compat mode for w95/98 a la Windows XP prompt, but only for desktop shortcuts.

What happened? Normal hyperbloat between os, libraries and network.

Only Windows has this issue. There's nothing about my Mac or my Chromebook that is anything less than immediate. You can quibble about whether the compositor introducing an extra frame of latency was worth the tradeoff, but that is on the margins.

The Mac is no better, in my experience. I just timed how long it takes to open the Calculator app – the simplest app I could think of – on my 2019 MacBook Pro, and the window appears 600ms after clicking on the dock icon. I would not call that immediate, and it only gets worse when you try more complex applications, especially those written in Electron.

VSCode is ~1s.

Terminal ~300ms.

iTerm ~400ms.

Calculator ~300ms.

Firefox ~1s.

Textedit ~200ms.

Slack ~1s to appear, ~5s to load.

Sequel Ace ~800ms.

Fork ~500ms.

All my subjective experience, but it's basically instant in experience. I think it also helps that it doesn't show fade in/out animations, which LOOK sluggish to me.

M1 MacBook Pro from 2020...

Code comes from the same shop that writes Windows. However, I would compare that with older software of similar purpose and capability. How long does it take to launch Visual Studio '97? According to some youtube screen recordings, VS '97 needs over a minute to draw a window even with a hot file cache, which is consistent with my memory.

On my M1 MBA, I just tried measuring opening Calculator using QuickTime screen recording, and then the "trim" function to determine 10 ms precision. It takes 260 ms. Definitely fast enough for me.

Shoe-horned and duct-taped "security."

This has nothing to do with snappy apps and everything to the complication of graphics sublayers, along with the difference of VGA vs HDMI, etc.

Is this even true?

How many applications were tested?

“What Andy giveth, Bill taketh”

Windoes NT on a machine from the day was incredibly slow. I remember opening Netscape Navigator and took minutes.

iOS is pretty fast though.

Everything in ios has animations that gives the appearance of sluggishness

But the worst part: people contributing on this site are contributing to this hell too.

Open the task manager n00b.

In modern windows the task manager takes much much longer to open than it did 10years ago

Sometimes, but opening it shows you what you is making things go slow.

This is hard to understand, windows is slow, and you are complaining that windows is what, slower than it used to be?

Why not use something faster? I get no lag with xfce

Reply on news.ycombinator.com