Sergey Nivens - Fotolia

Evaluate Weigh the pros and cons of technologies, products and projects you are considering.

Sustain high quality in low-code app development

Organizations can keep their standards high and their programming low if they follow these guidelines for a low-code, model-driven approach to software development.

With too few qualified application developers to meet voracious demand, organizations need a way to cut back on the code, not on the apps.

A shortage of professional developers has existed for more than 30 years. To better keep up with demand, the industry created descriptive programming languages, often called fourth-generation languages, which were easier for business professionals to use. However, while you could make the task of building software easier, building good software was another story.

Low-code app development is a form of model-driven development (MDD), wherein the organization or team assembles high-level components to create an app, rather than coding app functions and features. Componentization enables developers to work with complex units rather than primitive instructions, as evidenced in code-heavy practices with microservices and class libraries. Low-code continues this abstraction process up into business functions, with the aim to maintain software quality but simplify software creation.

At one end of the low-code app development spectrum, developers can build software in a similar fashion to service-oriented and microservices methodologies. The other end borders on no-code, so people with business skills -- not just software skills -- get involved in software processes. Both sorts of low-code tools share strategies for quality control and link back to the same model.

Start with a professional model

All low-code development is based on the black-box approach, in which a software component is a box whose external properties are the only ones visible. It's clear what that box does, but how it accomplishes the task is opaque. A black-box design insulates the user from the complexities of code-based software development -- the more general the model, the less software development skill involved.

To maintain high-quality software products, use professionally built components as part of the MDD approach, even if those components are then assembled by citizen developers from the business world to construct low-code apps. Well-built components will help ensure software quality, as long as you make sure to select and string them together sensibly.

Build for a purpose

Behavior-driven development is the strongest mechanism to integrate software quality compliance with low-code app development.

Software quality also relies on whether the application assembled from model components actually fits its mission. Form a strategy to keep software on track at both the concept/design level and at the implementation level. In design, follow a guiding methodology to translate business requirements into a sequence of steps -- these steps map to components provided by the low-code app development toolkit. Even low-code programming needs well-defined business goals, stated in terms low-coders can understand. For implementation, systematize workflow sequences in the low-code application assembly. While low-code is already popular, development methodologies that address the quick business-to-applications transition still have room for growth. Currently, behavior-driven development (BDD) is the best option. BDD is an approach that works backward from expected outcomes to set the app's process sequences. BDD relies on test definitions, the expected data transformations that testing would validate. Those transformations inform the sequences of process components. Because QA relies on testing, BDD is the strongest mechanism to integrate software quality compliance with low-code app development.

BDD techniques and tools require the user to define functions based on expected outcomes. Intermediate-level BDD tools suit organizations in which developers lay out the basic structure of the apps and define the main functions. Less-skilled personnel then refine and expand apps to suit needs. Jasmine, for example, enables BDD with low-code to construct JavaScript applications using Ruby, Node.js and Python.

The problem with intermediate-level tools is that they require professional app development in the initial setup. Right now, the momentum in the low-code space is with highly architected tools, often called development platforms, which deliver essential BDD features and systematize the entire low-code app development process. They resolve two major sources of software quality issues: inconsistency across the low-code process and lack of effective collaboration among project stakeholders.

Dependencies matter

Architected low-code tools can also help address another technical barrier to high-quality software: dependency resolution. Software can break if the functionally correct and professionally developed components that make up the application are not assembled in a logical path. Drag-and-drop, low-code app assembly or even an application built by functions connected by simple service calls requires that each component works with the output of the prior component. The low-code app development platform should generate a warning of incompatibility any time this logical path is violated. Change to a common data structure should trigger a remapping of all the processes that use that structure. Ensure mapping and remapping, as well as appropriate warning systems, are in place to enforce high software quality during low-code app development.

If BDD solves the planning and conceptual challenges of low-code approaches, then dependency management might take care of the technical challenges. In a behavioral software model, the operations that convert input to output define functionality. That model easily links to the data dependencies of each low-code unit. Therefore, the functionality of a low-code app comes from the behavior progressions and data mappings of each premade piece.

Low-code app development is indicative of the value of modular functionality, from programming-heavy techniques, like functional blocks and microservices, to the business-friendly, no-code models. As long as we leave professional-level problems for developers to solve and use low-code inside a complete development environment with properly applied software quality checks, no one should fear diminishing code lines.

This was last published in August 2018

Dig Deeper on Test-Driven and Model-Driven Development

Join the conversation

1 comment

Send me notifications when other members comment.

Please create a username to comment.

Can low- and no-code platforms create any kind of application that businesses need?