In the development of complex and long-lasting enterprise software, there is a demand for solutions that are reliable and scalable throughout the entire lifecycle. One way to keep enterprise software flexible in the long term and manage increasing complexity is through model-based software development.
Today, customers expect comprehensive functionality and long-term adaptability from their business applications. While advanced technologies and platforms offer new possibilities, they also introduce additional complexity into the development process of long-lasting enterprise software.
New Dimensions of Complexity in Enterprise Software
1. User Interface and User Experience (UI/UX)
In complex business applications, good UI/UX design plays a crucial role. The goal is to provide users with an optimal user experience without distracting them from the complexity of the underlying systems. This is achieved through the development of a user-friendly interface (UI) that is easy to understand.
Given the increasing threat of cyberattacks, developers must implement increasingly sophisticated security measures to ensure the integrity and confidentiality of data.
3. Cloud and Containerization
In recent years, the traditional division of tasks between software development and application operation has fundamentally changed. Many tasks that were previously performed in data centers as part of operations are now integral to projects. It is assumed that applications can run in containers and be deployed in various cloud environments. To meet this requirement, an additional and significantly more extensive application layer is created within projects, which did not exist in the past.
Furthermore, globalization plays a crucial role. Software projects are often carried out by teams distributed across the world. Coordinating these teams and integrating their contributions into a unified system significantly increases complexity. Overall, the combination of these factors makes the development of modern enterprise software increasingly complex.
Hamarz Mehmanesh, CEO of mgm technology partners, emphasizes, “Enterprise software applications with complex business models, processes, and data are always integrated into the company’s application landscape. It must be understood that the newly added dimensions of complexity further exacerbate the already complex situation of large projects. Mehmanesh is convinced: “In today’s world, large, isolated enterprise software projects are no longer justifiable. Costs are enormous and constantly rising, while project risks are increasing.”
Model-Based Software Development: Simplifying Complexity
To simplify the complexity of this type of enterprise software, the use of techniques from the field of model-based software development (MBSD) is recommended. In this approach, models are at the center of the development process and actively drive it.
Models are not tied to a specific technology and provide a simplified representation of the technical details of a solution. They use a formalized language that is understandable by both humans and computers to describe the functionality of the software and its tasks.
Build Process in Model-Based Software Development
The resulting models can then be used as the primary inputs for a toolchain in model-based software development. This toolchain can verify the conformity of various models, analyze them, and automatically generate parts of the software to be developed. In model-based software development, this is a sequence or collection of software tools used to support the entire development process, from software modeling to generated source code. The toolchain automates the development process and facilitates collaboration between different modeling and implementation phases.
When models are adjusted, the corresponding source code is automatically generated without additional effort. This not only reduces manual efforts and development costs but also increases software quality by systematically implementing the modeled concepts in source code.
Empowerment: From Subject Matter Experts to Co-Developers
The key advantage is that even employees in companies and business analysts can independently create and maintain the models to a large extent, as they do not require programming skills for this purpose. The modeling tools are no more difficult to use than Microsoft Excel.
For the functional part of the application, the work of software developers is eliminated. However, business testers can already test parts of the application based on the models. This means that the focus of development shifts from programmers to experts referred to as “Citizen Developers,” giving them significant freedom and making them practical co-developers.
Shared Requirements and Language Accelerate Software Development
The technical foundation of enterprise software is often very similar and comparable in many cases. When specifications are captured in models, developers can leverage a model-supported platform instead of starting from scratch each time. This not only significantly accelerates the development process but also enhances the reliability of the software. This is crucial for efficiently developing large software systems, especially in complex organizations where smooth collaboration between different departments and teams is essential for the long-term success of software solutions.
Separation of Business and Technical Contents The use of models has another interesting effect: since the business logic—the business aspects—is written in a modeling language, it is completely separate from the technical foundation of the application. “This is a very effective feature,” says Mehmanesh. “It means that technological innovations can be implemented without the need to redesign the entire business component of the application.” This allows new techniques for UI design, server processing, or persistence to be introduced, for example.
Seamless Transition from Modeling to Implementation in Model-Based Software Development
A special feature of the project process in model-based software development is that at the beginning of the project, not only are specifications written, but also a platform is available. The created models can be tested on this platform. Since it is a real platform on which the models run, there is no difference between a prototyping environment and a real environment.
Then comes the implementation phase, and in the first implementation phase, the proportion of software development compared to software modeling is still relatively high. However, the technical foundation is more or less established. It is not yet complete but has reached a stable base. Starting from this stable base, the scope of modeling grows continuously and sustainably. At the end of the day, much more code is written in the models by business analysts than by developers who complete the platform according to project requirements.
Enterprise Low-Code Development
Low code has been a buzzword for several years now, and many aspects of model-based software development can be found in this approach. Typically, low-code platforms come with user-friendly graphical user interfaces (GUI) and drag-and-drop features, allowing individuals with limited programming knowledge to create visual models and configurations that are automatically converted into executable code.
There are excellent use cases for low-code solutions, especially in the development of enterprise applications. However, it’s important to distinguish between various low-code approaches, as existing low-code approaches vary significantly. Some providers offer platforms as closed ecosystems where users can click together and publish small applications. This approach has the advantage of quickly delivering ready-to-use results. The learning curve is low, and extensive prior knowledge is not required. However, they are not suitable for developing complex enterprise applications in the long term – unlike A12, a low-code platform designed for realizing enterprise software in complex IT landscapes.
“Data First” Modeling Approach in the A12 Enterprise Low-Code Platform
The A12 platform was designed as an open development environment closely aligned with a modern software developer’s toolbox. It offers flexibility to use various approaches depending on a project’s specific requirements.
What sets A12’s modeling approach apart from other low-code platforms is the “Data First” approach. Instead of creating a user interface first, modeling in A12 starts with defining the business relationships. This approach allows a clear separation between the business description of the respective domain and a specific application. It enables the use of business logic in different applications and contexts, providing high flexibility for the continuous development and maintenance of long-term enterprise software.
A12 uses the following types of models:
- Data Models: The first task in the modeling process is defining business entities and their interactions—known as data modeling. Using specialized modeling tools, both business analysts and subject matter experts can create and customize the data structures of represented entities, such as contracts or products, in document models. Moreover, it’s possible to define validation rules and calculations using an integrated kernel language to represent application logic. Additionally, relationships between data models can be described in detail using relationship models.
- UI Models: Building on the data models, business analysts and modelers can use A12’s modeling tools to create parts of the user interfaces. UI modeling focuses on areas where model-driven components are used. A range of specialized UI models is available for this purpose.
- Workflow: To model business processes (workflow), A12 uses the established BPMN 2.0 (Business Process Model and Notation) standard. BPMN models seamlessly integrate with A12 models.
- App Models: App models define the framework of the application and serve as a container for all other models.
- Output Models: The print model allows the creation of print templates used as a basis for generating accessible PDFs.
Simultaneously, A12’s runtime platform enables seamless integration of low-code applications with professional custom software development and system integration into fully integrated enterprise applications.
Hamarz Mehmanesh emphasizes, “The share of low code and custom development can vary significantly from project to project. Even within the lifecycles of an IT project, the effort involved in modeling, custom development, and system integration can vary. Each component of the A12 low-code platform has been designed to be flexible and adaptable. The main goal is to provide reliable solutions for common problems while offering the opportunity to make individual customizations for specific requirements.”
One particular advantage of using A12 becomes evident in situations where different applications need to interact. This is because A12 follows an approach where business knowledge and requirements are represented in models that can be used by different applications. This approach has many positive effects:
- Consistency: Using the same models in different applications ensures that the information is consistent. There are no contradictory or inconsistent data.
- Reusability: Instead of creating and maintaining similar information separately in each application, models can be reused. This reduces effort and the risk of duplicated or inconsistent data.
- Simplified Release and Dependency Management: Since models can be used across applications, managing updates and dependencies between applications becomes easier. Changes in the models automatically affect all affected applications.
- Reduced Testing Effort: Because the models are consistent, and changes in one application affect others, testing efforts can be reduced. Fewer tests need to be conducted since many scenarios are already covered by the models.
“We chose A12 as a low-code platform to make our enterprise projects more efficient and reduce complexity. At the same time, we standardized our practices, methods, and tools and optimized their use to develop the best possible business applications,” concludes Hamarz Mehmanesh, CEO of mgm technology partners.
Overall, A12’s model-based approach contributes to improving efficiency and quality in the development and maintenance of software in complex environments.
- Whitepaper “A12 – Low Code for Custom Enterprise Software”: https://www.mgm-tp.com/documents/A12_Whitepaper_EN.pdf
- A12 FAQ: https://www.mgm-tp.com/documents/mgm-A12_Enterprise-Low-Code_FAQ_EN.pdf
- Reference My ELSTER – Successful Implementation of the Requirements of an E-Government Portal: https://referenzen.mgm-tp.com/wp-content/uploads/2016-01-28_BayerLdsamt-ENG.pdf
- Definition of Low Code, Chair of Software Engineering at RWTH Aachen University: https://www.se-rwth.de/essay/Low-Code/
- Paper “What is the Future of Modeling?”: https://www.se-rwth.de/publications/What-Is-the-Future-of-Modeling.pdf