- Reuben Rapose
First of all, if you’re a fan of black-and-white, clear-cut distinctions, then you’re reading about the wrong topic.
In the tech world, the lines between many roles are blurred; like “PHP Ninja Dev”.
Just have a look at the job roles in the Data Science Industry.
Roles like Data Analyst, Business Analyst and Data Engineer are spelt different on paper, but most companies expect roughly the same kind of work out of all three roles —_ just take my word for it, I have worked as a professional Data Engineer Ninja Scientist (Don’t quote me on that)._
For the most part, what these “titles” mean depends purely on how the company you work for interprets it.
But let’s not get distracted, I’m not here to discuss the nuances of how these titles are different from each other — I don’t know much about that honestly.
About 2 years ago, I started my journey as an Entrepreneur and assumed the role of a “Tech Lead” at my startup.
_“Surely that won’t be too hard?” — _It was extremely hard, like sailing through the second level of hell.
The 3+ years of experience in Python that I had accumulated before this were of no use.
Programming Is Easy, But Software Development Is Hard.
Software development is hard because most people usually tend to skip the foundational steps, which is learning to create programs that do things that other people want to pay for, and all the difficulties which that entails.
I come from a background of competitive coding (mainly in Python).
But that didn’t teach me anything about developing a software product with the right UX and design choices, integrating several complex APIs or writing code for role-based authorisation logic.
When I started developing our first software product (An Ads Analytics Platform), I felt like a kid who was expecting to write an essay right after learning the alphabet.
Moreover, I didn’t have the luxury of taking a few months break from my business to master these technologies since I had already committed to a deadline, therefore I was only left with one choice — to learn and implement all these technologies in our product on-the-go.
It took me about 4 months to deliver this product.
During that period, I learnt that software development is a very complicated process that cannot be learnt by simply following a tutorial.
In order to be a successful software developer, I needed to not only write code, but also understand how that code works and interacts with the rest of the system.
While it sounds easy, I can assure you that there are only a handful of videos on YouTube that can teach you this skill.
Because understanding the nuances of how different technologies/frameworks operate together is something that can not be learnt by watching a tutorial video — It is something one must learn by “doing”.
It required me to familiarise myself with new concepts and terminologies/frameworks.
I spent more time reading through documentation, or watching video explanations to try and fill the gaps in my knowledge rather than writing actual lines of code!
( I found this video by Delba de Oliveira to be one of the best introductions to the React paradigm. )
After spending all that time learning, I realised that most tutorials sucked at explaining the actual process of Software Development.
They made learning & mastering a language or framework seem very easy — to the point that it made me wonder what the fuss is all about.
There is a huge disconnect between what is shown in tutorials, blogs, courses and what is actually used in enterprise grade applications.
And, in my opinion, this seems to be the biggest reason why it takes people months or sometimes even years to reach the end of their software development cycles.
For example, most react tutorials teach you how to read data from external REST APIs, but very few videos talk about the importance of using React Query — which is a hook library that eliminates repetitive code, and introduces production-ready data fetching and caching practices ready to be implemented out-of-the-box.
Almost every real-world application would require you to build out the logic for data fetching and in most cases would require the use of something like React Query.
By the time I had made this realisation, I had to go back and re-write almost 2000 lines of code within an application that was otherwise ready to be launched in a month — it was either that, or I would have to spend weeks debugging and optimising my application/servers after delivery which would have been very time-consuming.
The process of Software Development is a combination of a dozen or so important decisions that one needs to make before writing even one line of code.
You have to think about your architecture, database design, tech-stack, cloud hosting, caching and even that is barely scratching the surface.
Software Development is a complicated process that requires you to understand various domain-specific concepts, specifications, testing, scaling, setting timelines, designing the architecture and most importantly choosing your “tech stack” like cloud service providers*.*
Since I had no prior experience in developing software, thinking about architecture or choosing the right tech stack; my journey was a little rough.
After going back and forth for about 4 months, and writing nearly 20,000 lines of code, the software development was finally completed… although, the journey was still far from over.
I was now faced with new set of challenges — Maintenance.
Maintaining software is a topic that has had very little light shed over it by experienced developers of the world.
If you’ve ever tried to update or fix a piece of code that someone else wrote, you would know how frustrating it can get.
There are a variety of reasons why it can be hard to maintain code, but some of the most common reasons are:
- The code is difficult to understand or is poorly written.
- The code is not well organised and it is difficult to find the code you need.
- The code has been modified so many times that it is difficult to track down the original source code.
- The code is no longer supported by the original author or the company that owns the code.
Complexity of code maintenance is one of the main reasons for the high failure rate of software projects.
In order to keep a software system running smoothly, the code must be constantly updated and tweaked to account for changes in the business environment, new requirements, and advances in technology.
This is a daunting task, and it’s often difficult to find the time and resources to do it properly.
As a result, many software systems become bogged down with legacy code that’s difficult to update and maintain.
Eventually, this would lead to performance issues and security vulnerabilities.
We battled these issues early-on during our development by focusing our efforts on writing code in modules (breaking it up into smaller, reusable components), and reusing them to reduce the amount of code that needs to be rewritten or updated each time there is a change in the business environment or system requirements.
Planning out our modules in advance is something that helped us address the problems associated with code maintenance and made the process easier and more efficient.
It saved us a lot of time and money, and it also helped ensure that our code is more reliable and secure.
In conclusion, Software Development & Maintenance are heavily misunderstood topics.
Their complexities are not understood by inexperienced developers because they usually lack the depth of expertise needed.
It is something you will learn once you dive into the deep end of software development & delivery.
Thanks for reading!
If you liked this article, feel free to checkout Seeking Within— a weekly newsletter covering a wide range of topics exploring the belief that Most Answers We Seek Lie Within Us.