Julio Merino is a software engineer born in Barcelona and currently living in Seattle. He decided to do it a few days ago. an experiment. Recovered an old computer from 2000 with a 600 MHz Pentium, 128 MB of RAM and a traditional hard drive. When it opened it found something wonderful: Windows NT 3.51 (freshly installed) applications. they opened instantly.

This user was not satisfied with that and wanted to repeat the test with a slightly more modern operating system. Windows 2000 installed on the same machine and by running the same tests and opening applications, he saw how they all opened at once. Response times were almost non-existent and there was a feeling that everything was running at an extraordinary speed. He explained this and more in a long post, both on Twitter and on his blog.

It then ran the same test with a much newer Surface Go 2 based on a 2.4GHz Core i5, 8GB of RAM and an SSD drive. With a clean install of Windows 11 it followed the same application boot sequence and checked as follows: opening hours were much slower. What was going on?

It can be said that this Surface Go 2, although much more modern than the 1999-2000 PC, is not really high-spec to run a demanding operating system like Windows 11. Merino took that into account and wanted to run this test, but do it on a Mac Pro with a 3.5GHz 6-core processor and 32GB of RAM. It’s unclear whether you’re running Windows with Bootcamp or virtualization, but in any case the video shown was stunning in terms of boot times.

As he explained, even with cached apps it seemed like a lot of work to process them, and they kept appearing “in chunks”. As he states, “not because of the animations or mediocre hardware.”

It also had nothing to do with the fact that it worked in 4K resolution, and even when disabling animations it was noticeable that a modern machine and operating system is apparently slower than a machine and operating system from more than 20 years ago.

The question is, of course, inevitable. What’s going on?

PCs and SSOO from 20 years ago were no better (except for some things)

The user commented in a thread on Hacker News that his intention was not to convey a message of the “machines 20 years ago and SSOO was much better” because, as he put it: that wasn’t true. In fact, they “absorbed in many ways,” he explained.

Things have improved in many areas, and we have computers and software that do things that were unthinkable 20 years ago, both in the development and execution of applications, and in professional tools, games, or video and audio content.

Progress has been spectacular, but not everything looks better: modern user interfaces they slowed down a bit (but also more elegant, customizable and eye catching) and it can be noticed that even on the latest generation PCs and laptops it can take longer than expected to launch an application.

Abstraction (and many more), the culprit

There are several reasons why such a thing happens, and one of them is definitely how the evolution of software and hardware itself has gotten complicated. Our machines and software do more, but what you need to do them well solve many problems and enabling hardware and software components to properly communicate (“talk”).

For a user to want to open a file explorer window, even if it seems trivial, requires the operating system to talk to the hardware so that both the I/O subsystem and the graphics subsystem (among others) can view folders and files. and do it via a window “drawn” or rendered by the graphics chip hardware.

Communication between hardware and software is done by calls. hardware abstraction layers (HAL for Hardware Abstraction Layer). Applications do not access the hardware and its resources directly, but an abstract layer provided by that technology. This ensures that apps are hardware independent and you don’t have to worry about the details.

But many other components (and problems) generated by the structure of modern operating systems are added to the abstraction layers. The processes may not be programmed asynchronously, there may not be enough parallelism, or the message forwarding and synchronization systems (those who have studied this field will surely remember mutexes) may not be fully fine-tuned.

As if that weren’t enough, modern operating systems include many services and software. work in the background and that they may not be necessary in many scenarios. No longer system processes, but application processes that “require space” to run from the moment we install and start the PC.

In fact, even Steven Sinofsky, who was responsible for the development of Windows 7 and also Windows 8, answered also with an interesting comment: modern operating systems integrate a web browser, something similar to the operating system itself.

The slowdown problem of Windows (and other operating systems) is well known. In fact, this behavior confirms Wirth’s law, which tells us that “software slows down faster than hardware accelerates”. A few years ago, the experts at NTDotDev conducted a detailed analysis of how Windows 10 is performing. it was getting worse shift.

With every version of Windows 10, the opening time of UWP apps has gotten worse in almost every case. Source: NTDotDev.

Successive versions of Windows 10 – including its major updates – have come with interesting improvements, but also additional problems. Performance degradation in certain sections was one of them and components like UWP or UWP Win32 application support (“old” ones) hurt the overall user experience.

Such analyzes have also appeared in special cases. Bruce Dawson, a Google employee, described his particular “fight” a few months ago with a Windows voice recorder that took too long to boot up and was almost “pedal-operated”.

Dawson, who specializes in profiling processes with tools like ETW (Event Tracing for Windows), eventually analyzed the execution trace and checked how several processes – and particularly importantly, the RuntimeBroker called RuntimeBroker – were inexplicably lengthening their execution. A developer named Katelyn Gadd responded on Twitter by stating possible reasons and giving an opinion that most of us are probably thinking about: “someone was probably lazy“.

Have programmers gotten lazy? It’s also an old question that refers to how times have changed in terms of hardware. Previously, developers managed to create great applications and games with little resources. Legend has it that in 1981 Bill Gates famously said, “640,000 should be enough for everyone.”

Gates has denied ever saying anything like that, but the truth is that for many people there is a feeling that “previous” programmers made better use of resources. Now that we have access to exponentially more powerful and resource-rich machines,”no need to try so hard” when creating efficient programs, because the hardware is already making up for the fact that the code can somehow be “lazy”.

This is true? Sure, in some cases. We’ve seen this in the Electron framework, which is widely used to wrap web applications and serve them as native Windows applications. This has saved software development companies a lot of time and effort, but developing “native” applications has been shown to significantly improve user experience and resource consumption.

So there may be lazy developments, but not all of them. Actually, as we commented performance degradation is the fault of the evolution of computing itself: Our operating systems, hardware, and software do everything they did before and much more, but doing so requires many components (some brighter than others) that we didn’t have before.

Image | Julio Merino

on Xataka | Restore the speed of a slow computer: 15 ways to speed up the computer