Low-Code & The Software Development Lifecycle
Tags: lowcode, programming, webdev, productivity
Published: 2022-10-20 03:34:30

## Writing Better Code With Low-Code

In simple terms software development is the process of going from a project idea to a software application. But there is a lot more behind successfully delivering software applications.

### The Software Development Lifecycle

The entire software development lifecycle is more than just writing code. It is a complex process that involves many different steps, from gathering requirements to handover. It also involves many different stakeholders: from business users and project management to, of course, professional developers, internal or external, with in-depth coding knowledge.


![The Software Development Lifecycle](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qe7eeqqrxnt8ifgx1hs7.png)

From the time that someone says "I need an app", there are usually at least six steps involved until handover & sign-off. For business applications, the process typically looks something like this:

1) **Choosing a developer:** who is in charge of developing the application? The in-house IT team? A professional development agency? Or maybe just a freelancer from Fiverr or Upwork? Letting the in-house team take charge of development means greater control and retaining knowledge in-house. But it can also result in timelines slipping when internal priorities conflict with the app development process. Choosing an external developer and agreeing on concrete deliverables and timelines can provide more leverage in meeting deadlines.

2) **Planning:** Next, the developer(s) and the client discuss the project requirements. Typically, three topics should be defined and agreed upon: the application scope, the project budget, and the timeline. It might be hard to meet all three targets at the same time. An application with a large scope that needs to be delivered within a tight deadline might require an additional budget. An application that is supposed to be developed on a shoestring and within a short timeframe might require adjustments to the scope. The client and developers should ideally agree on which one of the three dimensions - scope, budget, and timeline - has the most flexibility.


![Choose two out of three: scope, budget, time](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/trbyrwtm6zs19qpc2ahz.png)

3) **Choice of Tools:** once the software developers know the application requirements, they proceed by choosing the right tools for the project. Depending on the nature of the project (web application, mobile application, progressive web applications), different programming languages, frameworks, tools, or low-code solutions will be the best choice.

4) **Coding the app:** only now is the time to write custom code. Writing code before knowing the project requirements is usually a waste of time and is not recommended.

5) **Testing & debugging:** testing & debugging are the necessary evils of software development: never release untested software into production.

6) **Handover & project completion:** assuming all bugs have been fixed and the end-user acceptance test (UAT) was passed successfully, it is now time to hand over the application to the client.

### App Complexity & Custom Code

Let's zoom in on the fourth step: coding the app.

Depending on the complexity of the application, building apps can involve writing thousands, if not millions of lines of code. InformationIsBeautiful.Net, a website that publishes data visualization, shows the [explosive growth in codebases over time](https://www.informationisbeautiful.net/visualizations/million-lines-of-code/).


![InformationIsBeautiful.Net: The Explosive Growth in Codebases](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/coanjiy31doqc4z7gxic.png)

The 1993 release of Windows NT 3.5 contained approximately 7.5 million lines of code. Windows 7, released in 2009, already contained 40 million lines of code. Google’s entire suite of internet services consists of no less than 2 billion lines of code. A small, average software application still consists of approximately 40,000 lines of code. These numbers can be hard to comprehend for a non-coder (or citizen developer). For comparison, the Bible has 31,102 verses.


![Lines Of Code & Application Complexity: an average app has 40,000 lines of code](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xie4x9st303s8c1s0g54.png)

There’s a debate on how many lines of (production-ready) code a developer can write daily. Or indeed, whether [this metric is still useful](https://ifpug.org/content/documents/Jones-LinesofCodeMetricV6.pdf). But let’s engage in a thought experiment. Let’s assume that the average lies somewhere between 20 to 40 lines of production code. That’s already double to four times as much as [stated in a popular Quora discussion on the topic](https://www.quora.com/How-many-lines-of-code-do-software-engineers-write-per-day-How-many-lines-of-good-code-would-be-reasonable) that states: "The rule of thumb is 10 lines of code per day - of thoroughly debugged code."

Based on these numbers, a team of three developers would spend anywhere from one to two years creating an application. This is not an unrealistic time frame for a software development project, even though it is longer than [a study of more than 40,000 completed software projects](https://www.qsm.com/articles/long-term-trends-40-years-completed-software-project-data) published by QSM found. Based on QSM's findings, the average length of a software project (for 2010 and beyond) is 7.3 months, from the start of requirements (analysis and design) through the end of build & test when the system is put into production.

But regardless of whether the true number is 7 months, 1 year, or 2 years: this is typically more time than a business has to respond to a market trend. Technology is aging faster than ever, and rapid application development is extremely important for businesses digital transformation and to thrive in the digital economy.

### Better Code Through Low-Code?

Computer programming is an interesting field because there is typically more than one way to achieve an outcome using code. Different software developers will come up with different solutions to the same problem. Some will be more elegant than others. But one thing remains true, regardless of approach: good code runs smoothly and is easily readable & maintainable. Otherwise, there's a high chance of developers creating technical debt, rather than sustainable software.

As Bill Gates said, less is more when it comes to writing software:

> “Measuring programming progress by lines of code is like measuring aircraft building progress by weight.” – Bill Gates

Using low-code for software development can help reduce the number of lines of custom code, increasing the overall maintainability of software applications. Low-code application platforms, sometimes also referred to as application Platforms as a Service or aPaaS, aid software developers in three ways.

**First, they relieve software developers of the mundane work of having to write code for every form, field, and report.** By providing pre-built components that can be extended through full code, the platforms take care of the mundane, while the developer still maintains control and flexibility.

**Second, they increase reliability and security.** By using a standard platform with standard components, developers can speed up the development process by using what has been tried and tested by the platform provider. Think of an aPaaS in the same way as a car platform. Modern car manufacturers build multiple models and marques on shared automobile platforms. This shared foundation instills best practices and standards into every car that is manufactured on the same platform. It also means easier & cheaper maintainability as components are shared across multiple different models. Low-code platforms, for example, can take care of the non-functional project requirements, as these are standard components of the platform. By some estimates, non-functional requirements make up 40% of the time it takes to build applications. With a low-code platform, this can drop to almost zero.

**Last, good application platforms offer more advantages to software engineers than just faster application development.** As mentioned at the start of this post, the entire software development lifecycle is more than just app development. It involves things like testing, debugging, and deployment. That's where features such as application environments (typically development, testing, and production), or instances are very beneficial. Setting up different environments to build, test and deploy an application can be time-consuming. Not so inside a low-code solution that provides multiple application environments, or a debugger, out-of-the-box.

Overall, low-code introduces standardization to software development. It accelerates the development of the most common application components on top of pre-built non-functional requirements. And it still gives developers the opportunity to create unique solutions with unique functionality by extending their applications through full code.

The result? Fewer lines of custom code. Fewer vulnerabilities. A better software engineering process. Faster project completion. And more reliable software that is easier to maintain.

## Five & Application Development

At Five, we take a hybrid approach to low code. True to the spirit of “low-code software development”, developers can add full code to Five's pre-built components almost anywhere. Five offers components that can be quickly used and re-used in the software development process, such as forms or charts. Developers can then inject custom code in multiple ways and languages (JavaScript, TypeScript, or SQL). This makes applications created on top of Five almost fully customizable. All of this comes on a platform that takes care of deployment to the cloud. Five also offers three discrete environments per application (and application instance).

Ready to give this a try? Simply [sign up](https://five.co), download a free version of Five and start developing!

---

Originally published at [https://five.co/low-code-and-the-software-development-lifecycle/](https://five.co) on October 10, 2022.