Small code & the road to a sustainable software businessdittofi
The success of today’s organizations is dependent on the quality of their software. But what are the characteristics of quality software? And how can these characteristics be leveraged by an organization to gain & then keep their competitive advantage?
First, the businesses’ decision makers need to appreciate that in this day & age, software can be either your greatest asset or your single point of failure. From this realization, they need to make a sustainable strategy for software development.
Creating a sustainable strategy for software development must begin by aligning the creation of your software with the mission of the organization. This means that if your business’s goal is to revolutionize trading on the stock market, your software will need to be built for speed. Alternatively, if your business sells jewelry online, you should invest in a smooth visual display that captivates your audience, optimize checkouts & optimize yourself for search engine rankings.
But businesses are not static. So the key concept to understand is that sustainable software must be built in such a way that it can continually evolve with the organization. Furthermore, if the software becomes divergent it must be realigned to your core business values. To think of software as an inanimate object is a mistake. Your software is as much alive as the business itself & carries with it its own history.
So what are the characteristics of quality software that facilitate this type of symbiotic relationship between a business & its technology? Or, phrased more bluntly… can software that is built right be changed with less effort than software built wrong?
Quality Software Is Built on Small Code
High quality software is easier to bug fix, add features to or modify in any way than bad quality software. There are many points to consider when defining what quality software is. For instance the extensiveness of testing, modularity, lines of code & so on. But one of the most practical pain points that I have come across when building sustainable software businesses is the size of the company’s code base.
In the same way that a long essay that meanders around a point is difficult to follow, a code base that is unnecessarily long makes it harder, more time consuming & sometimes even impossible to read & adjust. And, if we can’t adjust our code quickly, then our software cannot evolve with our business. This is why one of the core tenets of sustainable software is small code.
Some interesting points that everyone, technical or non technical, can understand about small code:
- The odds of failure for a software project are directly proportional to the size of the project. Smaller code, higher chance of success.
- The relationship between lines of code & bugs is linear. Fewer lines of code translates into fewer bugs.
- The less code there is to read, the more likely it is that someone would actually read it.
Don’t confuse small code with “no code”
As businesses try & make code smaller & smaller, the logical step seems to be that eventually code will be gone all together. This might well happen if someone creates a general purpose AI that evolves without the need for human intervention. But it is arguable if this is even possible.
However, to the uninformed, there is danger in the term “no code”. No code, in the context of rapid software development, is used to describe systems that are built without the need to write code. This might sound great, but no code platforms obscure the reality which is that they actually generate code in the background… you are just not permitted to see that code.
No code is dangerous for a whole slew of reasons. If, for example, we return to the essay analogy. An essay with missing paragraphs could be impossible to understand. In the same way software built on a no code platform can be difficult or even impossible to fully understand. And, issues at the core are impossible to change without access to the no code platform.
Companies that have integrated no code solutions heavily into their businesses will find it difficult to sustain the relationship between the growth of their business & their software. Without access to their source code in the long run it will always prove impossible & they will end up with a reliance on the no code providers to help them evolve their software as their business requirements change.
The road to sustainable software requires businesses to appreciate that software is as much alive as the business itself. The same way that businesses carry history, so does the code that these businesses are built on. If I sit down in a bank, I have no idea why someone chose to code in COBOL. But presumably it was the best choice of language at the time when the system was developed or it was the one that the developer who designed the system favored. All of this is part of the company’s history. And the longer the code base, the harder it is to understand & change.
As companies look for ways to adapt faster & remove legacy debt, more & more businesses that want to gain a competitive advantage & keep it, are familiarizing their developers with auto code generation technology. Auto code generation technology allows users to configure business requirements & then automatically turn those requirements into high quality code… small code that is standardized (easy to read), safe, scalable & bug free. Using auto code generation technology makes it much easier to evolve the software at the speed of business decisions which, as we saw with COVID-19, can be an entire overhaul of business strategy within 48 hours.
About The Company
dittofi is a no code technology designed & built by a team of highly dedicated, passionate & skilled software engineers. For employment, partner or investment opportunities in dittofi please contact firstname.lastname@example.org or email@example.com.
Later this year dittofi will release a second wave of code generators targeted at analyzing even bigger data sets, AI code assistants & customizable analytics. These will include high performance plugins in C / C++, Python & Julia for general consumer use & ownership.