Open source: a solution to the obsolescence of electronic devices

By /

The frustration we feel when an electronic device becomes too slow… We all know it. That smartphone that lacks storage space or RAM, preventing us from installing new apps or updates. That computer that manages to perform its updates, but that has become so slow that the user experience becomes difficult. In the end, these frustrations prevent us from using our devices properly and push us to replace them.

Computers, smart TVs, smartphones, connected watches… These devices are evolving on an inescapable path of obsolescence. The decision to replace an electronic device is the result of a cumulative process of deficiencies, both in software and hardware, resulting in limitations in the use and operation of our devices. Furthermore, we find the fashion effect, because as human beings, we are constantly looking for performance and innovation.

To learn more about the relationship between the obsolescence of our devices and their software: go here.

In this article, we’ll explore how using open-source and free software can actually make your devices last longer – meaning you won’t have to upgrade or throw them away as quickly.

Why talk about obsolescence and try to extend the useful life of our devices?

We know that most of an appliance’s environmental impacts start during manufacturing. So, if we can reduce the number of devices being made just for our own use, we’ll also reduce some of the emissions that come with it. This is one way to limit the tech industry’s impact on the environment. By keeping our gadgets around longer and choosing to fix or reuse them instead of buying new ones, we’re already doing something to make the digital world more sustainable.

But what is free and open source software?

The term ‘free software’ comes from the Free Software Foundation. It’s a movement that’s all about giving people the freedom to do what they want with software. They can run it, study it, modify it, and share their own versions with others.

The thing is, most commercial software – like Microsoft or Google’s programs – are locked away from the public. We can use them, but we don’t get any information about how they work, and we’re not allowed to make changes. The code behind these apps is private and hidden from our view.

On the other hand, a text editor like Libre Office, which has an open implementation and code, allows anyone to propose a change, create a copy of that editor, and create their own version. Free software focuses on the freedoms of those who use the software and defines four fundamental rules:

  • The freedom to run any software for any purpose.
  • The freedom to study and modify the source code, so we can adapt it to our needs.
  • The freedom to distribute copies of the software. If I use a piece of software and someone else needs it, I can make a copy and share it. If some people need help figuring out how to do that, the community can offer its support.
  • The freedom to improve the software and publish these improvements, so everyone in the community can benefit from them.

One of the main benefits of publishing source code is the ability of the entire community to more easily identify, detect, and fix problems and errors, propose new features, create their own versions, and control what happens behind the program.

Example: You want to use a video conferencing software. You have access to the source code, which is reviewed by the community, ensuring that your communications will be secure and not transmitted or sold. In this case, the control of the solution lies with the community and the ability for anyone to investigate and monitor what is happening. In contrast, with proprietary code, the trust in the software relies on the trust you can have in the entity behind it. You don’t have the ability to personally act to verify what is really happening behind the software.

That’s what free software is all about. There’s also a related concept called open source software. It shares some similarities with free software, but there’s a subtle difference. While free software is about giving users freedom and control over their software, open source software tends to focus more on the practical benefits of using an open-source codebase. This means that developers can use and modify the code to create something new and useful. The good news is that open-source software can still be shared and reused, as long as it’s done in a way that follows the rules of the license that applies to the code.

License, you said? They can get very technical and complicated, but you should know that licenses are the basis of open source or free software, since it is a legal contract that stipulates how we can reuse or use this code to create copies or other types of software. For example, if I want to create a program to conduct online conferences, and to do so, I rely on an already existing open source solution that allows me to create voice conversations on the Internet, then I can freely use this code, modify it and create my own version of the tool. However, the license under which this code was created in the first place may or may not require me to make my code public and freely accessible as well.

In short, with open source, or free code, you have the ability to look at the source code, see how a program, application, or library is created, and, under certain conditions, you can modify it, propose new features, create copies, or reuse this code for other purposes.

Open source ≠ gratis

The majority of software applications rely on open-source libraries, services, and frameworks that are maintained by large communities of developers. These communities provide crucial support for proprietary software companies, which often rely on these open-source components to build their products.

But here’s the thing: these open-source communities aren’t just abstract concepts – they’re made up of real people who are passionate about sharing and maintaining their work. They volunteer their time, expertise, and energy to keep the community going and ensure that the code remains stable, secure, and usable by everyone.

Some individuals and companies support certain communities or their employees by playing an important role in specific projects, but the vast majority of those who build the software we use are open source communities, and they generally do so on a voluntary basis.

Open source to extend the useful lifespan of our electronic devices

We’ve already talked about the different types of obsolescence. Here it is again, if you haven’t read it yet.

In short, there are three types of obsolescence:

  • Mechanical or electronic obsolescence: a component or battery that fails or deteriorates over time;
  • Software obsolescence: software updates that consume increasing amounts of space and resources, eventually slowing down the system. This can lead to an inability to perform basic tasks, such as taking photos or installing apps. In the end, an absence of security updates will render the system obsolete.
    Software obsolescence can be caused by a lack of support for older software, even if the device still functions perfectly. This can happen when the company responsible for maintenance and updates goes out of business or decides to stop supporting its products, leaving users with outdated software that’s vulnerable to security threats. For example, consider the new versions of Windows where you’re forced to upgrade to a newer version because your old computer no longer supports it. Without regular updates, the operating system becomes insecure and compromises your safety. This can create a cycle where individuals feel compelled to upgrade their devices, even if they are still functional.
  • Perceived obsolescence: it’s when an individual feels pressure to acquire a new device due to its comparison to other models or because of industry trends imposed by companies. Users feel the need to upgrade, even if their current device is still working fine.

What concerns us here is software obsolescence. It is important to understand that software has consequences for our devices, which can lead to obsolescence of our hardware, even in the absence of any physical defects!

➯ How can open source software help us combat obsolescence?

Let’s take a classic example: a computer that, after a few years of use, becomes slow, very slow. It becomes difficult to perform simple tasks such as sending an email, browsing the web, or reading a document. Even it takes many minutes for the device to start. Does this situation speak to you? There are probably a multitude of factors, but updates pf operating system programs play a major role in this slowness. This software has become so heavy and requires so many resources that the computer can no longer cope with it. Even if at the beginning, everything worked perfectly. This is because new versions and updates were designed to run on newer computers and not your old PC. Older devices and their lower capacities are therefore left behind and ultimately stop being used.

However, there is an alternative—for those who can and know how to do it, or who can rely on someone who does—that allows you to continue using your old computer for basic tasks. This involves installing a much lighter open source operating system that requires fewer resources and enables smooth performance of basic tasks. In other words, open source can help us extend the usefulness and lifespan of our old computers and phones that have been abandoned by private companies.

In addition to operating systems, this idea can be applied to software. Two versions could thus coexist: a standard version for recent devices with many resources, and a light version, specifically designed for older devices. Of course, security updates are also included for these lightweight versions.

Often, during software updates, we don’t necessarily need all the new features. As these features accumulate, we end up with a large number of unused options. In this context, a lighter service often proves to be more suitable, and the open source community can provide this alternative that allows us to continue using the device effectively.

An interesting example is related to IoT-type connected objects. Let’s take the case of a smart camera that you can access online. If the company that sold and maintained it goes bankrupt, you will have no choice but to buy a new camera, as the old one will no longer receive security updates, making it vulnerable and compromising your security and privacy. On the other hand, if the code was open access, the community would have had the opportunity to modify or update it, even after the company went bankrupt. And this can happen with the millions of connected devices that have been launched on the market. Open source thus makes it possible to extend their lifespan instead of throwing them away.

Additionally, open source can facilitate support for external devices and ensure compatibility between computers, smartphones, and other external devices.

Example: We have a computer that we want to connect an external CD drive to. This is because most new computers no longer have CD drives, so we have to use an old external drive stored at the bottom of our drawer. When plugging it in, our computer does not recognize the disk drive. What is going on? The problem is not related to the PC, nor to the player, it lies in the software that acts as an interface, which translates and carries out the communication between the computer and our CD player. Often, these dictionaries, called drivers, do not exist for the set of possible combinations between operating system models and external device models that exist.

In our case, the new version of our operating system probably does not include the driver needed to recognize our external drive, which is too old. What would most of us do? Buy a new CD drive compatible with our computer. Fortunately, the open source community has created and continues to create these dictionaries that allow us to keep using old external devices.

To achieve this, it is essential to understand how the computer and the CD player interact in order to establish effective communication between them. The manufacturers of these products must therefore be transparent, because even if the community wants to develop open source software, without this transparency, the creation of the interface becomes impossible. It is important that this interface is open source, allowing anyone with the necessary skills to improve or modify the communication between the device and the computer. It is this transparency that will allow us to extend the life of our CD player.

A CD player in our example, but it could be the other way around: we have a brand new webcam that we want to connect to our old PC. The consequences of incompatibility would be worse: if we really needed that webcam, we would have to change computers to be able to use it, even though the current one works perfectly. And as in the previous case, if the company that makes our device goes bankrupt, it is still possible to continue creating, maintaining the software, and using the devices if the code is freely accessible and the interfaces are open.

Another point related to this is that open source software encourages, or at least does not obstruct, the creation of operating standards. This is very important, as we explained in the case of interfaces between different devices. This is called interoperability.

A clear example of the benefits of interoperability is the standardization of chargers. Today, a smartphone is mainly charged through a USB port. Back in the day, for those who remember, each mobile phone or company had its own charger. This pooling of chargers, which is quite practical, grants more freedom since we are no longer dependent on a single company. Since it is an open interface, in this case, the charger, you can use other models of cables or chargers.

The issue with these interfaces being private, closed, and non-standardized is that they create a direct dependence on the vendor that maintains and updates them. This is often seen in the software industry where vendors use techniques such as restrictive licensing agreements or closed ecosystems to maintain control over their customers.

In hardware, this can manifest in devices that only work with proprietary firmware or those that are only compatible with other devices from the same manufacturer. Imagine a smartphone that can only transfer photos to a specific type of computer due to incompatible protocols or file formats.

Businesses often use tactics such as vendor lock-in to keep their customers tied to their products and services. This can lead to a situation where users become dependent on a single supplier for both software and hardware, making it difficult to switch to alternative solutions or use devices from different manufacturers.

An essential point: repair

The repair of household appliances is often due to a faulty or broken mechanical or electronic component. Even though this doesn’t necessarily depend on software, the possibility of replacement is part of the transparency and openness of technologies. There is a branch called ‘open hardware’ that seeks to ‘open up’ physical elements to bring the same notion of an open community to devices. This is the case, for example, with ‘Arduino.’ This possibility of replacement is also in line with the philosophy of free code or free software.

This transparency is very important for being able to carry out repairs. However, today we are still far from this openness. The operation of devices is opaque, they are difficult to repair by the general public, and there is a lack of public documentation to carry out certain repairs. This makes us dependent on specific companies to perform our repairs, which should be straightforward, like replacing a battery or a screen.

Several legislative initiatives have been launched in recent years to establish standardized metrics for measuring the repairability of devices.

The strength of community

In short, open source code allows customization, adaptation to user needs, repair or technical support. This will often result in an extension of the life of the devices, since it is possible to meet needs – which are not necessarily profitable for large companies.

But this doesn’t happen by magic.

The fundamental element for this ecosystem to work (creation, technical support, updates, etc.) is the community. Those who create software are human beings, often volunteers who, in their free time, collaborate, create, help test the software, redistribute it, or install it for others so that the community continues to grow and exist. Just like a private company, a community can collapse, resulting in open-source projects or software that simply cease to exist. The only difference is that anyone, thanks to open-source code, can take over this project and relaunch it. This is not possible with a private solution. It is important to be aware of this.

Open source allows for more security, openness, easy detection of vulnerabilities, interoperability or, as we have mentioned, extends the life of our devices and delays obsolescence. But if there is no one behind all this, these alternatives do not exist.

To support communities, you can participate, test what is being done, propose solutions to certain problems, help financially or with personal code. We believe it’s important that companies that benefit from a significant portion of this commons – namely code, libraries, and open source programs – make a contribution, in some way, to this community. In the absence of this reciprocity, no matter how much we want to see open source solve our problems, it won’t happen.

Scroll to Top