Computer hardware has improved drastically since the 1990s. However, the perceived performance to the user has (in many ways) not significantly changed. It takes just as long to launch an application; it takes much LONGER to get a response from a mouse click [0]; and it takes just as long to start your computer. Additionally, simple tasks that were once quick and easy are now time consuming and difficult. Some of the reasons why are presented in this article.

When programming a computer using a modern version of Windows, Mac OS, or Linux in Assembly or C (very low level languages), the programmer is not permitted to communicate with the memory directly. Instead, the programmer interacts with the virtual memory of the operating system. These multi-tasking operating systems may be moving large amounts of data in and out of memory and cache, and these transitions are largely uncontrollable by the programmer (and time-consuming). When using a solid state hard drive, even the operating system doesn’t talk to the storage directly. Instead, the drive has a flash controller inside it (most often implemented as a system-on-a-chip) that maintains the memory [1]. They keep track of which memory cells are broken, and provide some redundancy for data checks. In the other direction, much of our software is no longer an executable that runs on the operating system. Instead, it’s an application that runs on a virtual machine (e.g. the Java Virtual Machine, an interpreted language, within a web browser). So instead of creating software to manage memory directly (the most efficient solution), a programmer creates software that is presented virtual memory by the virtual machine that is presented virtual memory by the operating system that is presented virtual memory by the micro-controllers that access the true memory. These layers comes at a significant cost to performance; each layer incurs a delay, power consumption, and memory inefficiency.

Most of our computer’s memory is made with DRAM; DRAM is constructed as a set of very small capacitors. Each capacitor (or memory cell) must be refreshed regularly to maintain its voltage (and memory state) due to leakage current. This drains our computer’s batteries. Additionally, as we make DRAM with larger and larger storage capabilities, the capacitors suffer from cross-talk and fail at a higher rate. To compensate for this, we rely even more heavily on the memory controller. SRAM (used for computer cache) does not suffer from this problem, but it is much more expensive (about a factor of 100 times the cost of DRAM). Perhaps, instead of wasting more and more resources inventing intelligent systems to compensate for the failures of DRAM, we should be finding ways to make SRAM cheaper.

With modern multi-tasking operating systems, the operating system will interrupt the current process and determine if another process requires time on the processor. With Windows 10, these interruptions happen with a frequency of 60Hz. When the process is changed, the operating system will transfer data from RAM to storage and vice versa. Even when the process isn’t changed, though, the system’s interrupt still occurs to check if the process should be changed. This, again, is a time consuming process. Additionally, an inability to control the computer makes software optimization more difficult. When one makes changes, it’s unclear if minor differences in speed are due to changes that occurred with the operating system or changes that were made to the code.

Some people argue that these abstractions are useful, and that they permit a more rapid development of products. This is somewhat true; however, many of these advantages are lost to the developer and the user. For example, in Windows 10, Microsoft uses the operating system to show advertisements [2]. So we are purchasing hardware that is controlled by Microsoft and using our resources to show us advertisements that we don’t want to see. The Windows 10 operating system itself requires 1 gigabyte of RAM and a 1 GHz processor. That’s a billion memory cells that are lost completely to the operating system! That’s a billion cells that don’t make the user’s experience any better than it was in 1995.

Additionally, the earlier described abstractions permit laziness. As a simple example, languages and frameworks commonly used by web developers include HTML, CSS, Javascript, PHP, Python, and JQuery. And Javascript is an inefficient programming language [3,4]. If the web were constructed from scratch, no one in their right mind would claim that the way to create websites would be to have 6 different languages that one must learn! And each one, of course, comes with its own inefficiencies.

There are simple metrics that show how much of our computer’s performance we are wasting. I recently owned an ASUS netbook with an Intel Atom 1.66GHz processor (which cost me about $500 new) and ran Windows 7 starter. This computer struggled to show Netflix videos; its fans would whir and the video would routinely sputter. But a $35 Amazon Fire Stick can show Netflix videos just fine [5]. (I made this comparison on the same wireless network.) Additionally, users are finding that Arduino computers (entire computers on a single chip) are surprisingly capable. But with these computers, there is none of the bloat that I described earlier.

[0] https://danluu.com/input-lag/

[1] http://queue.acm.org/detail.cfm?id=2385276

[2] https://www.windowscentral.com/how-remove-advertising-windows-10

[3] https://twitter.com/Jonathan_Blow/status/713030547283423232

[4] https://twitter.com/jonathan_blow/status/540242900324343808?lang=en

[5] https://smile.amazon.com/Amazon-Fire-TV-Stick-With-Alexa-Voice-Remote-Streaming-Media-Player/dp/B00ZV9RDKK?sa-no-redirect=1