Low-Code & The Software Development Lifecycle
Low-Code & The Software Development Lifecycle
Put simply, software development is the process of going from a project idea to a production-ready software application. But there is a lot more behind successfully delivering software applications. But there’s much more to it.
In order to successfully deliver applications that end-users love, development teams typically follow a process called the Software Development Lifecycle (SDLC), a structured approach that turns ideas into high-quality software.
The Software Development Lifecycle
The entire software development lifecycle is more than just writing code. It is a process that involves many different steps, from gathering requirements to handover.
It also involves many different stakeholders, ranging from business users and project management to professional developers with in-depth coding knowledge.
From the time that someone says “I need an app”, there are usually at least six steps involved until handover & sign-off on the final application.
For business applications, the software development lifecycle typically looks 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 can 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.
A second decision to take during the planning phase is to overall approach to managing the development. The waterfall model and agile management are two project management approaches. Without going into too much detail, agile has been gaining in popularity because of its faster iteration cycles and quicker feedback loops compared to a traditional waterfall model.
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.
The fact that coding the application happens toward the end of the software development lifecycle usually surprises a lot of junior developers. But, as the saying goes: a stitch in time saves nine. The software development lifecycle is designed to avoid making costly mistakes early in project management.
Rectifying a set of requirements, wireframes or mock-ups is easy. Re-writing the codebase of an application is difficult.
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 visualizations, shows the explosive growth in codebases over time.
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.
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.
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 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 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.
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 resembles the use libraries or frameworks by encouraging developers to re-use code. Low-code platforms introduce 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 & The Software Development Lifecycle
At Five, we take a hybrid approach to low code. True to the spirit of “low-code software development”, developers can add high code to Five’s pre-built features almost anywhere. Instead of eliminating code, Five reduces code.
Five’s features can be quickly used and re-used in the software development process, such as forms or charts. This enables rapid prototyping, for example. 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 development, testing, and production environments per application and comes with an in-built debugger, making it suitable for the entire software development lifecycle.
Ready to give this a try? Simply download a free version of Five, and start developing! Happy coding!
