Model-Driven Development: The Foundation of Low-Code

What is model-driven development?

Model-driven development is the foundation of low-code development. The method abstracts the technical parts of developing an application (logic, data models, user interface, etc.) and transforms them into visual drag-and-drop components.

Using visual building blocks, stakeholders can show developers the problem or business need. The developer can then show the stakeholder what is possible and how to solve the problem.

And so, there are far fewer missteps, the process moves faster, and the finished product is more likely to be spot-on. The golden prize of business value is delivered. It’s a win-win all around.

Why is model-driven development necessary?

Collaboration and communication are difficult because business and IT don’t speak the same language. And traditional waterfall development processes only accentuate this problem.

Here’s how the traditional development process usually goes:

The business expert describes in their language what the business needs.
Developers try to understand business needs through the filters of software languages and IT architecture. And so they may only hear part of what the business expert is describing.
Then, business and IT don’t really speak much during the development process.
The delivered solution misses the mark.

It’s safe to say that most developers don’t attend business school. And most business school grads don’t know computer code. They’ve both learned different languages—the languages they need to be the best at what they do. But model-driven development creates a shared visual language that anyone can understand.

What is model-driven architecture?

Model-driven development gives users a visual interface. But it’s what’s underneath the visuals that makes all the difference. (You can have a visual interface that is not low-code, but you can’t have low-code without a visual interface.)

With low-code, the model abstracts away from the code. Instead of complex languages with rigid syntaxes, you have building blocks or “pre-built application components.” Each has its own domain-specific language (DSL) that handles all the technical aspects of the application (the logic, data model, user interface, security, integrations, etc.).

These components or “pieces of functionality” are abstracted and presented visually to users. This creates a common language that everyone on the team can understand, from business domain experts to hardcore developers.

When exploring solutions together, they can see what each other is talking about, arrange and rearrange the components, and then quickly test the application.

That magic is automation, another fundamental aspect of model-driven development. The processes underneath the top layer of drag-and-drop visual development are all automated, including:

Configuration
Testing and QA
Integrations
Various housekeeping chores

Professional developers are relieved from several tedious tasks. This is a primary example of how low-code boosts productivity and accelerates the development process.

How to build a model-driven application without code

The question many ask at this point is: How do I use model-driven development to build an application without code?

Low-code platforms are specifically designed to help you build apps without code. But the fact is, there are some low-code platforms that still rely on code. Some visual models are interpreted into code that becomes the application. And with that comes all the traditional pitfalls, like quality and ops issues of typical code-heavy applications.

In true model-driven applications, the model itself is executable in the runtime with no need for code. When you don’t have to write and troubleshoot code, the process is exponentially faster and the finished application is higher quality.

In cases where you need functionality that is not available in one of the prebuilt components, a professional developer can write code to build custom components. Then you can make the component available to other developers in the community through the low-code platform’s marketplace (i.e. Mendix Marketplace).

Model-driven development and BizDevOps

Model-driven low-code, by definition, brings the idea of BizDevOps to life without a second thought.

Business experts are integral to the process because of the intuitive visual modeling tools that eliminate the mysteries of code. They can even build applications themselves. Even with zero code knowledge, they can drag and drop their way to a working application.

The development team gets a big boost in speed and productivity thanks to the visual model. And through automation, they’re relieved of the mundane and repetitive housekeeping tasks that zap productivity and morale.

Developers don’t have to spend much time making choices about languages, data structures, logic flows, and architectural matters since the model makes the right choices for them.

And from an operations perspective, everything is faster and easier thanks to the automated processes, quality checks, and push-button deployment built into the model.

Open and extensible model-driven development

With technology that changes in the blink of an eye and new tools sweeping over the landscape—IoT, AI, augmented reality, blockchain, edge, etc.—the challenge for software is adaptation and integration.

A model-driven low-code platform is the ideal tool to handle future innovation. For example, model-driven development with Mendix is open and extensible at every level. This allows professional developers to enhance app capabilities and work on more sophisticated business solutions. Developers can easily integrate Mendix with existing tools and technology using our Model API and software SDK.

Abstract it all away

Using a model to abstract away from lower-level code empowers everyone on the team to focus on higher-level concepts and solutions. Automation also enhances app quality by:

Boosting productivity
Relieving the burden of mundane, repetitive tasks
Reducing human errors

Openness ensures connectivity to everything everywhere, from legacy systems to emerging technologies. The results are more relevant, powerful applications, built faster than with code-centric platforms. This is the power of model-driven low-code development.