Your phone was faster yesterday than it is today, and will be slower tomorrow. Bit Rot is a real thing.
Computers are kind of like people — as they age they tend to get a little slower and flaws are easier to see.
Our phones are computers shrunk down to be pocket-sized and easy to carry around. And that means as time goes by, things aren't happening as quickly as they used to or things can get a little buggy. This is universal; it happens to Galaxy phones and LG phones and Pixel phones and iPhones and every other phone that does more than make calls and send texts. Some people say they don't see it happening, and that's because of why it happens and the way software is written for all the different phones out in the wild. But it is still happening on your phone right now, and always will be.
Let's take a look at what is commonly known as "Bit Rot" and see if we can't understand things a little better.
What is Bit Rot, exactly?
It's a term that gets thrown around a lot by people who are into computers, and it basically means that the software is "old" and has become slower than it used to be. There are three things at play, and they're well documented even if they're not very easy to understand: Software Erosion, Software Entropy, and Software Bloat.
First, some outliers
Sometimes there can be other factors, too. Data Degradation and Feature Creep can cause programs and apps to slow down, but they're easier to explain and are a little different than what we call Bit Rot. Data Degradation is a fancy word that means your memory — either the RAM, the storage or both — is getting old. RAM and Solid State media require an electric charge and over time it can disperse more than it was designed to do. This means some of the stored bits (software bits) can be changed. When a few bits are wrong, many programs can compensate but that takes time and the programs are a little slower. When a lot of bits are wrong things pretty much stop working as intended.
Data degradation and feature creep can make your phone slower, too, but are different from Bit Rot.
Feature Creep is easy to understand. Your phone was built with a specific set of software in mind. When you get an update that adds more features, the hardware has to work harder and things get slower. Online forums are filled with people who hated a recent update on their Galaxy phone and people with older iPhones who hate the latest version of iOS. That's because the software was written with newer and more capable hardware in mind, just like the software your phone originally shipped with was. We all love new features and updates, but the old adage "be careful what you wish for" is right on the money here.
These issues can certainly have an effect, but they're different from Bit Rot and probably aren't contributing much towards any slowness on our phones because we don't keep them long enough to see it in action.
Software Erosion is the slow but steady deterioration of performance that can happen to any software, whether it's something we use a lot or just a little. Or even never. This happens because we use the software and all applications change when they're used — we add user data to the base so that the software does what we want it to do. Note that this is different than software getting slow or buggy while we're using it a lot but goes back to normal with a restart. That's usually due to small errors accumulating over time or a memory leak. You can't fix Software Erosion by closing and re-opening an app or restarting your phone.
All software has bugs and all software needs regular maintenance it never gets.
There are two different types of Software Erosion, dormant and active. Dormant software erosion happens when a program or parts of a program you don't use stop working well because other things changed, and active erosion happens because of changes while you're using it. Both types happen because of a few different reasons.
- Unused or leftover code can (and often does) contain bugs that don't get caught.
All software has bugs, no matter what a developer of user says. When a company changes some code there's a very good chance some of the original code is never going to be used but is still built into the final product. Bugs here aren't as likely to get caught and can have an immediate effect or one that takes a while to show up.
- Changes because the software isn't user-friendly happen a lot.
A developer builds software with a specific idea of how we will use it, but once it gets into our hands we often don't use it that way! Sometimes this isn't our fault and software has a poorly implemented interface so we do things a developer never thought we would. Other times it is our fault and we do things like make multiple accounts or run multiple instances of an app or function that wasn't designed to run that way. This can leave user data or cached data that is more difficult for an app to process.
- Lack of updates and maintenance are bad.
Any developer will tell you that the job isn't finished once the program is published, and software needs to be maintained. This means fixing bugs users find, but also frequent updates to work well with other software. Lack of regular maintenance across the board is the biggest cause of Software Erosion.
The "Android" that runs on your phone is actually a big group of independently running programs and services that need to communicate with each other constantly. An example: Facebook makes another change on their servers, then updates the app in Google Play. Your Contacts app ties into Facebook, so it might need an update. Or your camera gets an update but the gallery application that's tied to it doesn't. All the parts of the system need to work with all the other parts, and that means regular maintenance.
The good news here is that a lot of Software Erosion problems are fixed with a factory reset where all the user data is wiped. The bad news is that it all comes back eventually.
All software that we can't change has bugs and unused code (see above). These bugs will probably stay unchanged over time, but can get worse as the complexity of software we can change increases. This is called Software Entropy.
The software you change affects the software you can't change because the system itself gets more complex.
Most of the software on your phone is in a closed system. You might be able to update the keyboard or camera app from the Play Store, but the bulk of the operating system is installed at the factory and only changed with a full system update. This is very different from all the apps, both factory-installed user apps and ones you installed yourself. The software you can change gets more complex over time and the software you can't change has to deal with it.
The people who wrote the software on your phone are pretty darn smart when it comes to all of this. But nobody can know the things we'll do, what new apps will be capable of doing, and how apps designed for one set of APIs (application programming interfaces), for instance, Samsung's APIs from their software development kit, will work with apps designed for another set of APIs, like the ones from Google that are part of Android. The developers have to do their best to guess and make the software in a way that won't break and hope for the best.
There are two ways to fight Software Entropy — regular software maintenance through timely updates, or resetting the user software back to the factory state.
This isn't what the name suggests, though extra bloatware apps can and do cause things to run slower. Software Bloat when talking about Bit Rot means software that is filled with extra or unused features.
The more features added to any program, the more complex it will be. Complexity makes applications slower.
"Extra" features are impossible to define. Apps, or parts of apps, that I don't use are extraneous to me, but you might use and love them. From a computer's point of view, the only good application is one that does only one thing then closes itself once finished. This is impractical from a user point of view; imagine a keyboard app that closed after each letter was typed. The companies that make the phones we love have to find a happy medium between features and performance by using the right hardware or cutting back on features in apps. That could mean adding more RAM and using a faster processor or trimming features from an app, or both.
Another part of the "extra" features is software that has to be able to handle multiple (and often competing) standards. Your email applications are a great example of this. If you use Gmail and use the Gmail app, things are a lot more streamlined than they would be if you're using the other email app with a Gmail account, or an Exchange account, or something like a Yahoo! POP3 account. The Email app has to be able to do things the Gmail app can't, and has to be able to handle the different types of data we create. This takes time to process and as we add more data it takes more time.
Perhaps the best example of "extra" features and how they affect performance would be comparing Evernote and Google Keep. If you only use the app to take notes, all the extras in Evernote mean it takes a lot more time to add or read them. If you like those extra features, you'll quickly find that Google Keep just can't do most of them. There is no right or wrong here, but this does have a big impact on performance.
Unused "leftover" features can still run and cause problems, and our phones are filled with them.
Unused features are more frustrating because we don't know they are there and we couldn't do anything to change things if we did. When a company like LG (we'll pick on them here, but this applies to every company making phones, even Google) makes a phone with their own apps that are duplicates of "stock" android apps like the phone dialer or the calendar, there is a lot of leftover code that isn't being used. Some of the code still runs when you start your phone, too. We've talked about how this means bugs will be harder to find in that portion of code, but it also can have a big impact on performance. And when Software Entropy is factored in we see how those bugs can get worse and worse over time.
So what does all this mean and what can I do about it?
That's an easy question — it means that some phones are slower than others and some phones get noticeably slower over time while others are less affected. And there's not really anything we can do about it.
More features mean slower software and more opportunity for Bit Rot to happen. It's a trade many gladly make.
Real talk — a phone like the Note 8 is noticeably slower (and shows it when attached to tools that monitor performance) than a Pixel 2. The Note 8 will get even slower six months or so down the road. But the Pixel 2 will never be able to do some of the things a Note 8 does, no matter how many apps we install or how we hack the crap out of it. I can annotate a screenshot with the S Pen immediately after I capture it on the Note 8, but on the Pixel 2, I have to share the screenshot to another device to annotate it with the same level of features and detail.
Like the Evernote vs. Google Keep argument above, what's better is largely a matter of features that you like. The Note 8 has all the features. This means it has all the bugs and software bloat that makes Bit Rot more noticeable. This could be a problem for you, but for others, it's not because there is no other way to get the feature-set. This is why there are more Android phones than just a Pixel and Pixel Plus and what everyone means when they say Android gives you a choice.
And when Bit Rot ever becomes enough of a problem that you need to do something about it, just factory reset your phone and take a few hours to set everything back up.
Sound off in the comments below!