Model-Driven Development: The Most Important Concept in Low-Code

Model-Driven Development

We’ve introduced the nine principles that are fundamental to the concept of low-code application development. All are essential, but if we had to identify the one principle to rule them all, without which there would be no low-code development, it’s the first principle: model-driven development.

What is model-driven development?

Model-driven development bridges the programming language divide to improve collaboration and communication between business domain experts and software developers.

Models, rather than lines of code, create a common, visual language. Working with visual building blocks, the domain expert can show the developer what the problem or business need is, and the developer can understand it. The developer, in turn, can show the domain expert what is possible and perhaps some novel ways to solve the problem. Back and forth they go, reaching understanding and agreement before proceeding to each next step.

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

With a foundation in model-driven development, Mendix was founded to improve collaboration and communication between business domain experts and software developers. The purpose of the Platform is to accelerate the process of building business apps while also enhancing app relevance and quality.

Why is model-driven development necessary?

The biggest impediment to collaboration and communication is that business and IT simply don’t speak the same language. The traditional waterfall development process accentuates rather than solves this disconnect.

Here’s how the process usually goes:

  • The business expert describes in their language what the business needs (in the reqs process)
  • The development team understands the 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.
  • When the solution is delivered, months or even years later, it 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.

Model-driven architecture

While model-driven development gives users a graphical or visual interface, 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 with 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, creating a common language that everyone on the team can understand, from business domain experts to hardcore developers. When they are exploring solutions together, they can literally see what each other is talking about, arrange and rearrange the components, and then, thanks to more magic in the model, quickly test the application.

That magic is automation, another fundamental aspect of model-driven development. The processes underneath that top layer of drag-and-drop visual development—all of the configuration, testing and QA, integrations, and various housekeeping chores — are all seamlessly automated. This relieves the professional developer from a number of tedious tasks and is a primary way that low-code boosts productivity and accelerates the development process.

How do you build an app without code?

The question many ask at this point is: How do you have an application without code?

The fact is, there are some low-code platforms that rely on code because their visual model gets 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, low-code apps, the model itself is executable in the runtime; there is no need for code. With no need to write and troubleshoot code, the process is exponentially faster and the quality of the finished application is higher.

And in those cases where functionality is needed that is not available in one of the prebuilt components, a professional developer can write code to build their own component that then becomes part of the model. The component can then be made available to other developers in the community through the Mendix Marketplace.

The ultimate realization of BizDevOps

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

Business experts become integral to the process because of the intuitive, understandable visual modeling tools that eliminate all the mysteries of code. They can even go so far as to build applications themselves. With zero knowledge of code, 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. They don’t have to spend a lot of time making choices about languages, data structures, logic flows, and architectural matters since the model makes the right choices for them.

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

Openness and extensibility

With technology that changes in the blink of an eye and major new phenomena 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. Model-driven development as designed by Mendix is open and extensible at every level, giving professional developers opportunities to enhance app capabilities and work on more sophisticated business solutions. Developers can easily integrate the Platform 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—both technical and business professionals—to focus on higher-level concepts and solutions.

Automation relieves the burden of mundane and repetitive tasks and reduces human errors, thus enhancing app quality and boosting productivity.

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

See what’s possible with the Mendix low-code Platform