Why Good Code Matters

Updated! This is an updated version of the original article. Last Update: November 13, 2020

The future of your business depends on the code that you write today.

How? What? How does this even work? Who wrote this? Often, these are the internal thoughts of a senior developer at CodeCoda when looking at a client’s legacy code for the first time.
Let’s begin by taking a couple of steps back. A client has approached us with their project idea, contracts are signed, plans are set, and now it’s time to write some code. Sometimes, this involves taking a client’s current codebase and making the required upgrades for the future.

The moment before seeing a client’s codebase for the first time, there is always a mixture of excitement, fear, and general curiosity. Then, pandora’s box opens, and strange things come to light. Some clients have a very professionally written codebase. Although this may sound a bit nerdy to a non-coder and other humans alike, another coder would use terms like beautiful, elegant, or clever to describe it. Such a high-tier description can tell a lot about the author of the code.
You see, code itself reveals some insides about the person who made it, like when artists leave a piece of their mind in every art piece they produce. An elegant code talks about the author’s passion, standards, and ideas. A right code preserves a lot of that character so that other team members might recognize who wrote a code just by looking at it. Neat code is a clear indication of the great creator behind it, and one, we think, with a stellar career ahead of them.
There is also the other side of the spectrum: code so poorly written that those “how,” “what” thoughts start to appear more frequently. Often, behind a clumsy code stands an overly enthusiastic amateur. We use “amateur” because the author didn’t understand how to code. The mortal danger here is that bad code can literally take down a business.

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

Robert C. Martin (Uncle Bob)Author and Software Engineer

One clear example is lousy code in sensitive functionalities like authorization or log-ins. Hackers love security holes like these and will immediately take advantage of it. We already know that cybercrime cost is in the millions, and code flaws only make it easier for criminals to abuse poorly written code - an easily avoidable mistake.
One of the worst examples of having a destructive code is when bad lines become part of the initial version of an app or website—the earlier the mistake, the graver the consequences. One tiny code glitch in your start-up project may mean weeks of horror during all consecutive system updates and upgrades. What’s even worse is that more buckets of code are getting poured in as the project grows. Without constant code clarity, there’s a good chance that an occurring code glitch could quickly devaluate any otherwise crucial advantages like an outstanding design or quick navigation.

Coders should always aim for high standards when writing software tools. In fact, coders have sets of rules that help them stick to writing “good code,” which is valid for any programming language. Most programmers avoid poorly written code very seriously, which separates the boys from the men. A coder whose work practice is set to allow poorly written code to slip in is bound to fail sooner or later, and maybe fail a whole company as a terrible side effect. We know this happened in the past, and it most like will again.
We recommend more testing and QA to avoid such traps, focusing on code design, refactoring, and even cleaning code description within the code. Experienced programmers understand that what they do someday may be looked at by a different pair of eyes. Reducing code ambiguity is also great for improved teamwork, making it easier for colleagues to cover for you, advance your code, or at the least, understand the code with minimum effort, interpretation, or, in worse cases, need for imagination.
The complications every industry is experiencing due to the adverse effects of Covid-19 have brought clean code into the spotlight, deservedly. Before the pandemic, lousy code occurrences may have slipped the decision-makers’ attention since errors posed a lower impact on business disruptions. Now that the crisis has hit us all to some degree, companies with error-free codebase prove that they are better equipped to survive through hard times. We believe that with social distancing and personal health reaching top priority in our lives, building an online business during crisis takes a lot more than strong determination. Writing a clean code now that the risks have risen has never been more relevant.

A well-written code is dependable, reliable, and, perhaps more importantly, easily upgradable. Companies with a stable codebase are more flexible to change and adapt to a success path, and this is what we at CodeCoda are geared up to achieve for our clients.


David Dorr, Head of eCommerce

David is the Head of e-Commerce at CodeCoda where he is responsible to lead several teams of eCommerce specialists. In his previous role as a data scientist for London Metropolitan Police, he was developing deep learning NLP algorithms as part of the Crime Prediction initiative. He then switched over to combine AI with e-Commerce.
He received a B.Sc in Physics from the University of Surrey, Guildford in 1996. With this scientific background, he switched relatively early in his life towards Neural Networks and e-Commerce and has ever since been fascinated with what AI and Machine Learning can do for Online Commerce.