Industry software development in the last ten years or so it has been experiencing a period of obvious decline. Due to some circumstances and trends that I will explain later, it seems that the industry has become addicted to easy solutions that are not necessarily the best in terms of code quality and maintainability.

Many users may have noticed recently how software monopolizes more and more resources however, at the level of processor, RAM, graphics and disk space, in many cases this increased resource utilization, which in some cases is even exponential, does not translate into improvement in a reasonable or justified sense. This does not only apply to video games, but can also be seen when compared to, for example, local audio players, an area where certain “new inventions”, despite the simplistic patterns of the past at the interface level, end up consuming more resources than older applications with more features .

The conclusion that can be drawn is that software tends to “take up” more resources to do the same thing instead of consuming more to offer significant improvements to the user. This isn’t always the case, and I’ll give an obvious example in this article, but it’s clear that recently much of the software we use has deteriorated, and it’s no longer strange to see apps and video games officially launched in an apparently unfinished state, and sometimes not a ton repairs cannot correct the situation.

Hardware that is very powerful

The context I am dealing with in this article is complex and multi-faceted, but there is no doubt that the power that hardware has acquired over the years is one of the main reasons why software is apparently increasingly neglected.

To understand this point, you need to ask yourself only one question: what is old hardware? Perhaps more than one reader was wondering where to place the barrierand it’s because the sixth generation Intel Core i7 is a very competitive processor today that can handle practically everything in the home environment, including playing heavy video games, if it is supplemented with adequate graphics.

By stripping it down and making sacrifices, even an old Intel Core 2 Quad can be more useful than its age might suggest, not only for basic office and basic tasks, but also for things like programming on projects that aren’t . a particularly large one, to give an example.



Another fact is that there is a PC market that has been somewhat weak on a general level during the second decade of the 21st century. What stands out here is the fact that many people have decided to replace their PC with a mobile phone, but this does not mean x86 computers themselves have been very powerful for a long time.

What’s more, even the fourth generation Intel Core i7, accompanied by a recent low-end graphics card, is able to run a behemoth like Cyberpunk 2077 with more satisfactory results, even if it is not with high graphics settings. In any case, unless one is a gourmand, a recent video game can look good even with medium graphics settings.

Apps use more resources without bringing great things to users

Apps are taking up more and more resources, CPU, RAM, graphics, and even disk space, and sometimes we experience the odd dismay/displeasure, as with Atomic Heart, which went from requiring 22 gigabytes of disk space to 90.

The fact that software tends to accumulate more resources is something normal and we could even say natural, but in the last decade there is one aspect that irritates many and that There are many who feel that the software has increased its hardware requirements a lot, but in return it doesn’t deliver an experience or improvement to justify said increase..

It is not necessary to turn to video games to see an example of increased resource consumption that does not yield great things in return, as this can also be seen by comparing other types of applications, such as local audio players. Here we have Audacious, a veteran of the segment who currently builds with C++ and Qt, and Amberol, who is built in Python and GTK. Although Amberol is a simpler application than Audacious, it ends up consuming more memory.

Another factor that may have contributed to the increase in hardware resources required to run software is the abuse of technologies that operate at a high level. Languages ​​like Python and JavaScript have come a long way over the last decade and are used for many things, including technologies that work at the server level and graphical applications that are installed locally.

At this point, we cannot forget some web applications promoted through framework Electron, which have legions of detractors mainly among Linux users, and rightly so An Electron application is essentially a standalone web page in the browser, which contributes significantly to the resources needed to run it properly.. Added to this is the traditional poor performance which Web applications.

Little work in polishing and optimizing the software and slow recycling

Since the PC video game market operates primarily through digital distribution, this has encouraged many developers to release games in their raw state, although more than once it has been pressure from investors and other unrelated development parties that have forced early releases.

Another point to consider is that the software development sector is a far cry from what is perceived from the outside, in fact it is quite conservative and resistant to change. This is evident in the video game industry where you can see it legacy APIs like DirectX 11 still hold their own against newer ones like DirectX 12 and Vulkan.

One of the reasons why DirectX 11 is more relevant than Vulkan and DirectX 12 is that the latter two require learning, while the old API is already widely known. DirectX 11 basically works, so why change it? This mentality also affects professional software such as Blender, in which it was possible to see how the development of its Vulkan support stopped before OpenGL, which, after all, worked and works, although from the creation and rendering solution Work on 3D graphics on Vulkan was resumed later.

From a “because it works” point of view, Vulkan and DirectX 12 seem to make no sense, but these APIs operate at a lower level and therefore make better use of the hardware, so the consequence of keeping DirectX 11 and OpenGL is to increase the hardware requirements in order to “fix” its limitations . It is true that DirectX 12 is starting to gain traction in the video game industry, but the transition is quite slow if we see that the API came to light in the middle of the last decade.

Because much of the software development industry is slow to update its knowledge, a perverse dynamic has arisen in which consumers are encouraged to buy ever more powerful hardware that will work under software conditions. outdated, instead of developers putting batteries to use technologies that make better use of hardware.

Chrome, a legitimate case of increased resource consumption (at least initially)

With this article, I do not want to criticize the consumption of resources itself, but rather certain trends that have solidified around it, especially that they do not bring great improvements in return or things that justify it. However, not all cases are negative, and Chrome (rather Chromium, the underlying technology, although I’ll focus on Chrome here for simplicity) was at least initially a positive case.

Chrome appeared fourteen or fifteen years ago like a hurricane, powered by the mighty machinery of Google. This browser, which is basically Chromium with some Google ingredients and is closed source (proprietary), known for using multithreadingwhich, compared to the competition, was reflected in a significant increase in hardware resource consumption.

Chromium, the technology base of Chrome.

Using Chrome with multithreading enabled to make better use of multi-core processors, which were already common at the time. As a result, Google’s browser clearly consumed more resources than Firefox, but in return offered much better performance and responsiveness, things that were even more valued on quad-cores, and not necessarily recent ones. What’s more, in 2016, before Quantum came out, Chromium browsers performed much better than Firefox even on an old Intel Core 2 Quad.

Despite the fact that Chrome was heavily criticized for the large amount of resources it monopolized and continues to monopolize, the reality is that most users saw that it compensated them, so Mozilla had no choice but to get their act together and implement multithreading in Firefox to attempted to engage user flight, something that has not been able to see the web browser market work since the advent of Quantum.

Conclusion

Trends in the software development industry over the past decade have ended up artificially increasing the hardware resources needed to use software, sometimes to make it work properly, other times because it takes up too much disk space, which in devices like the Steam Deck can force you to use a microSD card as additional storage solution.

However, not everything is pessimistic, as the last few years saw the emergence of Rust, a programming language that makes a lot of noise and has been making a significant place in software development for several years. Rust was born within Mozilla and currently operates independently. Its enthusiasts are pushing hard to get it into the Linux kernel, and it focuses on type safety, performance, and concurrency.

The issue here is not so much that Rust spreads on its own, but rather that it acts as an axis or becomes a reference for reviving certain ways of doing things that are lost in favor of taking the easiest path and delegating everything to hardware capabilities.

Cover image: Pixabay