What It’s Like As A Software Developer
I feel like I can speak with some clarity being on both sides as a freelance developer & product owner. Often times when I talk to people who are not familiar with software development and how much an average app costs, I get a myriad of responses between “That’s awesome!” to “Unbelievable, that’s totally BS.” I can’t blame the disbelief because I once was on that side as well. Because of that, I decided to write this article after a conversation with my co-founder, Ryan, about the topic. For clarity’s sake, I hope this provides a better understanding for those who are new to it.
“Why do you guys get paid as much as you do?” or “Why do you charge so much to make an app?”
The answer is simple: because the job isn’t easy. We as software engineers have to take up a lot of our time to tell stupid things to do incredibly difficult stuff. A good metaphor is like telling an infant to drive along the West Coast using a bus. Computers do not understand English at all, only Binary. Programming languages act more as a translator than an actual language itself. Your English written code is compiled into a low-level language that then translates whatever you write into 1’s and 0’s for the computer to read. In the real world, all languages function the same way because humans are smart. Before I move on, I must state that programming is very simple: Write instructions. However, by no means is it easy.
- Programming is not physically difficult, it’s mentally draining: Believe it or not, programmers use a lot of mental power to make something simple. Going back to the infant metaphor, imagine having to write out instructions step by step. I mean writing out every time he will hit the brakes, turn left/right, avoid traffic, get gas, how much he needs to put in and how far he should actually drive, on top of teaching him how to drive. If you can imagine, that’s not only something that can grow tedious, but it’s mentally taxing. Writing a module can take as long as a day simply because the code wasn’t clear enough for the computer to read. Between bugs and algorithms, you also have to keep in mind design & architecture.
- Most problems are not the same as the last: No matter how skilled a developer may be, they will always face a new bug they have never seen before. What makes things worse is that some bugs are totally out of your control. Not only are programmers builders but in order to be considered “good”, your debugging cannot be anything less than exceptional. This means a lot of detective work. IDE’s are notorious for not telling you exactly what the problem is, leading a lot of us to pull out our hair. One missed semicolon or incorrect line can totally wreck the code you have been working on for the past hour. Also for bugs that have never been seen before, you would have to creatively think of a way around it, which again requires a huge amount of mental power.
- Programming = Word Math: In software development, mathematics is literally everywhere, even in the words that you type. What makes it very obscure is that we mainly use Boolean Algebra: The math of True/False & Discrete Mathematics: The math of Algorithms. It’s different because it is not typically taught in schools unless your major requires it as a prerequisite, in other words not taught in grade school. By nature, software engineers are problem solvers, but are required to deduce and solve these problems mathematically. So now, imagine writing the instructions for the infant using math, instead of sentences.
- We NEED to know how everything works, even a little bit: This is especially true for a sole developer in a start-up that is scaling to a new technology. Contrary to popular belief, computers are one of the dumbest things on the planet so learning how it works is imperative. The problem with programming languages is that different languages are optimized for different things; some for front-end web, server-side, mobile and games. Even though most developers may not be what we call a full-stack developer, everyone needs to have a good understanding of everything, even in a high level.
- Things ALWAYS change: With technology changing every two years, we developers have to learn something new every time we code. For example, on mobile, I write in Objective-C but since Swift came out, I find myself dabbling into it here and there. That being said, I would write an app & about a month later, there would be a ton of red lines and a code that would not compile because Apple changed things. Deprecation is probably one of the most annoying things we developers have to deal with; it makes us look back on the documentation and change what we need to in our code-base according to those changes even though we write it out a couple of days prior. And this is just one example.
- At work, there is almost no routine: Like bugs, a new day presents something new, all the time. The pace at which you work will vary depending on the demands of the product owner and the deadlines he/she sets. There will be days where you are totally glued to your computer or days where you’re slamming your head on your desk because of a bug.
- Programming takes a lot of time: Just like with anything that is to be taken seriously, you would have to deal with a learning curve. Some people go through a four year university, some go through a bootcamp program and others are totally self taught. Regardless of how you learn, it takes a lot of time to get a good understanding of the concepts behind computer science. Soon after, you would have to learn how to apply those theories to your language of practice.
- Cave man or Creator: Believe it or not, seeing your code work the way you want it to can be such an emotional & euphoric experience. People may see a programmer as some kind of wizard but in truth, we sometimes have the most difficulty making the simplest functions work properly. One line of code can either make you feel like a genius or the biggest moron on the planet. And after working at a module for countless hours, seeing code work or crash can leave you sleeping well that night or feeling defeated.
- Our thinking has to be in a different level: Remember how I said that programming is mentally draining? The reason why is because we have to think like engineers. On top of building and breaking things down mechanically, we always have to think of the cause & effect of every module we write. Figuring out which pieces of code fit appropriately, consider every outcome where it can go wrong, what solutions we can implement to avoid them and what’s the best/most efficient way to build what we build as well as describe why we built it the way we did. It sounds easy in theory but in practice, doing this is fighting a totally different beast. However, those who are comfortable enough to write code & know what they are doing think like an Engineers without even trying. Everything looks like lego pieces and can see the way software works as patterns.
- Software Engineers are Engineers: By definition, an Engineer is someone who designs, architects, builds and maintains something with applying scientific knowledge, mathematics and ingenuity. Software engineers literally do all of that. We make something out of nothing, we solve difficult problems and make beautiful solutions to them, we turn ideas into reality. The only difference is that we don’t have to take a test at the end of learning how to become an engineer. Aside from that, the difficulty and job description are all the same, minus the titles.
I do always say this to people who ask how developers earn so much. Software devs get paid large amounts of money because they are enthusiastic about what they do, therefore become very good at it. Usually, that means that they see work and play as one in the same which could be hard to grasp for some people. These software engineers love building things, inventing and pushing the boundaries of software. These guys are usually the ones that come up with breakthrough technology. However, like I said, this will only apply if you genuinely like programming.
If you are considering making an app with a buddy who is already a programmer and just want to see the other side of things, I would give them a hug because as this entire article states, it’s hard work that people don’t notice on the surface. For those who are considering a switch in your career into tech as a software developer, I ask one question: Do you legitimately like building things? If so, read this article again and ask a programmer how it is like to be one. Also it is important to know that when learning how to program, adopting an engineer’s mindset or getting past “The Hump” as most people describe, it is the hardest part. Now, If your answer is still the same, I urge you to give this a shot. At the end of it all, I hope this gives some perspective into the work that goes with being a software developer.
Special thanks to my co-founder, Ryan Bruce Badilla & my good friend, Yi Chin Sun for helping me come up with a lot of the points in this article.