Apps have become the foundation on which we live our digital lives. They connect us with the people we aren’t physically near, they give us any piece of information we want in the blink of an eye, and they make giving in to our vices way easier now than ever before. But what powers all of this? Most people know about “the cloud” and a subset of those people know that it’s just a big room (or rooms) full of computers somewhere. People also know that the apps they use are connected to said cloud. That’s how Snapchat remembers pictures people sent you and how Twitter shows you tweets. Those apps are connected to some other, bigger computer which feeds that data to your device. Lets go one step deeper though. How does that app actually run? What’s going on to make your experience seamless (or not)? There are some things that are unavoidable that we as developers need to account for to make your lives awesome which, in turn, can make our lives miserable.
We Have To Cater to Computers
Not every problem has been solved, or if it has, sometimes it isn’t solved well. Developers don’t have the answer to every problem. If we did, our jobs would be a lot easier and technology wouldn’t be frustrating to use anymore. But lets face it. Computers just can’t do everything. As a developer, this one fact makes my job both interesting and extremely frustrating at the same time. Interesting because there are problems to solve and some that still need an touch of elegance, but also frustrating because problems never have only one solution. There are simple problems with simple solutions that are tried and true. Optimizations that have always been the “most” optimal of all possible optimizations you could make. But there are times where you have to introduce bottlenecks. And on top of those bottlenecks are reliability issues. The biggest offender being connectivity. WiFi sucks. Cellular service sucks. Developers wish there was blazing fast connections with 100% coverage all of the time no matter where you were. That’s the ideal situation. Everything just works in these conditions. Of course, I’m talking about software that relies on an internet connection to deliver you content (most apps these days). For games and such there are different limitations. But for most of the apps we use, a connection to a remote location is key to the app’s purpose. We can’t expect people to have the latest and greatest devices all of the time either. So not only are we facing obstacles with communication between 2 different computers, we’re also dealing with the limitations of devices people have. Not every device supports LTE speeds. Not every device supports cellular service in general, so what do you do when WiFi cuts out? What do you do when the device can’t accomodate for your app? Since we don’t have control over these things we have to work around the limitations of technology.
Sometimes We Don’t Know What We’re Doing
Limitations bring problems to solve, and sometimes we just don’t know what we’re doing. Being a developer isn’t all about coding. It’s mostly about thinking. I’d say I do about 80% thinking and 20% typing. That’s why my typing speed still sucks, but my ability to solve problems has greatly improved. BUT here’s the kicker. Just because you’ve thought of a solution to a problem doesn’t mean it’ll be a 1:1 mapping into code. Why not? Because computers suck and we have to cater to them. They only understand a set of primitive instructions. They can’t do high level operations like we can unless we build that out for them. So what do we do? We build it out for them. We start throwing functionality into the app and stuff that you as a consumer will never see or know about. We’re building the cogs and putting them into place to solve a problem. Everything seems to go well and things start falling in to place until… BOOM! Everything starts falling apart before your very eyes. Turns out, the cogs you had jammed into place affected other cogs. So what do you do? You start moving things around and placing them into the “most logical” position possible. Once done you think “this is the best solution. It makes sense, it’s elegant, everything works, it handles all of the potential points of failure, etc.” Then another developer comes to look at your fabulous work and rips it all apart. It’s worse than seeing the red pen on a test that was handed back to you. Everything you thought was true in the world is pulled out from under you in one critique session. And as you’re looking through the comments you start seeing the light. You start asking yourself questions they’re asking you. “Why did you do it this way and not this way?”, “Shouldn’t you do this to accomplish that more efficiently?”, etc. Coding is a constant battle with your past self. You will always look at your past work and wonder why the hell you did it that way and you’ll think to yourself “did you even know what you were doing?”. There are those moments, though, where what you write is the most beautifully written solution to a problem. It’s efficient, well written, and bullet proof. It’s what every developer aspires to write 100% of the time. But we can’t do that all of the time because, in the moment, the truth of the matter is we may not know what we’re doing.
People Have Different Goals
Developers want to write the app the right way, the business wants the app shipped as soon as possible, and design wants the app to look great. The goals of the designer and developer take a lot of time, but there’s a time constraint with the business. At the same time, the business needs a certain list of functionality completed for a minimum viable product. This puts a lot of pressure on the developers to get functionality done while also building the designs the designer envisions. What happens is, if the project isn’t planned out well and resources aren’t allocated well, things tend to progress slowly. Then the backlog of work starts to pile up. Meanwhile, the deadline creeps up on everyone, so the developers start implementing features as fast as they can. This leads to carelessnes and bad code. Every developer has had those moments where they had to implement a workaround for a bug that seemed to never go away. No one knew an answer on any forum or the only answers suggested were adding a ton of extra noise to the code base just so the app wouldn’t crash. It’s frustrating but also nerve-racking having a workaround in your project because you know what to do to make it break. You know if you do a certain set of actions in a certain order that it will cause unexpected behavior. And sometimes that’s just how it has to be. Other things take priority and push those minor fixes back. New features take precedence over refactoring and bullet proofing the application. This will keep spiraling until there are a lot of these workarounds in the app and everything becomes fragile. Adding new features becomes cumbersome because you spend 90% of the time fixing other parts of the app that break because of your addition. All of this stems from the small workarounds implemented throughout the app. The small hacks that make the app work enough to get it out to users.
Apps Are Controlled Hacks
Apps aren’t entirely hacks though. Sure, there are a few patches that get something to work enough to be acceptable. There are tricks we need to pull out of our sleeves to get the experience being requested by users working. But admist all of this craziness, there is some order. There are guides and best practices for each platform. Developers review other developers’ code. We always do our best to minimize the amount of “hacks” we put in our apps as a service to ourselves, our co-workers and, most importantly, our users. We strive for excellence in our work and we’re passionate about the products we work on. Whenever a bad review comes in, we developers know about it and want to correct that the best way we can because without users our product would be nothing. So, yes, sometimes, as a user, you may be receiving something that’s being held together by scotch tape and/or band-aids in some spots, but it’s all to deliver you a product that you’ll be happy using. A product that will help you in life and give you more time to be with the ones you love most.