Model Driven Architecture for Industrial Applications

Several difficulties commonly arise during the software development process. Among them are the lengthy technical process of developing a system, the limited number and technical capabilities of human resources, the possibility of bugs and errors during the testing and implementation phase, dynamic and frequently changing user requirements, and the need for a system that supports multi-platforms. Rapid application development (RAD) is the software development life cycle (SDLC) that emphasizes the production of a prototype in a short amount of time (30-90 days). This study discovered that implementing a model-driven architecture (MDA) approach into the RAD method can accelerate the model design and prototyping stages. The goal is to accelerate the SDLC process. It took roughly five weeks to construct the system by applying all of the RAD stages. This time frame does not include iteration and the cutover procedure. During the prototype test, there were no errors with the create, read, update, and delete (CRUD) procedure. It was demonstrated that automatic transformation in MDA can shorten the RAD phases for designing the model and developing an early prototype, reduce code errors in standard processes like CRUD, and construct a system that supports multi-platform.

Manufacturing companies today face an increasingly dynamic environment. Development of production planning systems requires approaches that offer flexibility in development of solutions. Applying the UML (Unified Modeling Language) and MDA (Model Driven Architecture) paradigm can ensure compatibility between applications developed on different platforms. The MDA approach to software development becomes an obvious choice. In this approach, the models drive the process of software development. These models are defined at different levels of abstraction to represent various aspects of the system. The transformation of models from one level of abstraction to another, or the transformation of models to executable code is performed by using automated transformation tools. The strength of MDA lies in the fact that it is based on widely used industry standards for visualizing, storing and exchanging software designs and models. The models in MDA are abstracted at three different levels – the Computation Independent Model (CIM), the Platform Independent Model (PIM) and the Platform Specific Model (PSM). The key to the success of MDA lies in automated or semi-automated model-to-model and model-to-code transformations. In this paper, we examine how a platform-independent model of an MRP-based production planning system can be created using MDA approach, from which several platform-specific systems can be achieved, as required.

The model driven architecture (MDA) is an approach to software engineering in which models are systematically developed and transformed into code. This paper discusses some of the issues which would need to be overcome when attempting to certify a safety critical design or software developed with the MDA approach, partially based on our experience with an avionics software case study. We particularly focus on the need to certify MDA artefacts and produce a compelling system safety case

The Model Driven Architecture (MDA) approach is emerged in the last years as a novel software design methodology for the development of software systems. In this approach the focus of software development is shifted from writing code to modeling. In MDA, developers implement models that are automatically transformed into the target code of the system. Alongside MDA, the Model Driven Testing (MDT) is emerging as a relevant research topic in both industrial and scientific communities. MDT is a methodology where test cases for the system are automatically obtained starting from test models to maximize specific model coverage criteria. Eventually, test cases are executed to verify the system code that is generated through an MDA approach. In this paper, we conduct an exploratory study in order to evaluate the differences that may exist between the model coverage guaranteed by the test cases and the code coverage reached when they are executed on the auto-generated code. Moreover, we identify the main factors that may influence these differences.

A way to specify component-based software architectures for embedded real-time systems is introduced. Component models are specified taking the Model Driven Architecture (MDA) approach, and employing UML notations. First, the principle of the developing process based on the MDA approach and the new concepts of UML-specified component architectures are addressed. Then, a conceptual framework architecture for the design of embedded real-time systems is presented, in which platform-independent component models are built. Taking specific platform features into regard, specific component models result from transformations mapping the platform-independent component model to either the Process and Experiment Automation Real-Time Language (PEARL) or to Function Blocks according to IEC 61131-3 or IEC 61499.

In many scientific and engineering areas there are emerging software services available over the Web. The reason for deploying such services in the Cloud is either to reduce the operational costs or to support the peaks in their usage profiles. The algorithms employed in such services are usually result of a long term research and technology development work, so it is beneficial to reuse those critical application parts when developing new Cloud applications. This paper investigates the possibilities to introduce a Model Driven Architecture (MDA) for the Cloud computing domain, which would support composition, customization, flexibility, maintenance and reusability of Cloud application components in the particular case of scientific and engineering applications. The underlying middleware technology of choice is the mOSAIC Platform as a Service (PaaS) solution. This choice is motivated by the fact that in mOSAIC a Cloud application consists of loosely coupled components, which are either generic and provide for key resource types needed by an application (computation, storage, communication) or custom made, e.g. based on existing legacy software. The MDA approach is illustrated through the design and operation of an application for analysis of structures under static loading. It is shown that a relatively simple design can be used to address two application bottlenecks: the varying number of users and the computational complexity of the given problem. The design reduces the necessary application development efforts and the key components can be reused for similar applications.

SummaryThe Model‐Driven Architecture (MDA) is an approach that aligns modeling and automation for software development. By applying such an approach to data warehouse (DW) projects, we can minimize a great deal of time and cost. Furthermore, most of OnLine Analytical Processing (OLAP) platforms seem to be like black boxes that provide wizards only to business intelligence developers to create and manipulate OLAP objects without allowing their sustainability and migration from a platform to another. That is why many works in the literature have proposed using the MDA approach in DW projects. However, most of them have mainly focused on the generation of the DW relational model from the conceptual one, and they overlooked the OLAP model and the cube implementation.To deal with this problem, we propose in this paper an MDA solution to automate the process of getting OLAP cube and its implementation through a set of metamodels and automatic transformations among them. In fact, the proposal generates the OLAP and DW relational models (PSMs) from the conceptual one, using also a PDM model that describes the target business intelligence platform. After that, the source code to create the cube is got from both PSM models. For this aim, we define a set of transformation rules implemented using the Atlas transformation language. Finally, a case study will be provided to validate our approach.

Software development is a complex process and the information technology market is faced by many challenges. Among the challenges is the effect of technology "platforms" change (languages, operating-systems, interoperability solutions, architecture frameworks etc.). Model Driven Architecture (MDA) is a new development method as a positive effort from the Object Management Group (OMG) to overcome software development problems including but not limited to technology change. The philosophy of MDA regarding technology change is the separation of concerns. In MDA, structures and behaviors based on the business functions are abstracted and modeled in a Platform Independent Model (PIM). The implementation specific structures and behaviors are modeled in a Platform Specific Model (PSM). The PIM is then realized into the PSM through a mapping process to automatically generate the software. Current practice shows that MDA approach works quite well but, in most cases, behavioral models are used for other purposes like documentation rather than complementing the structural models to facilitate automatic software generation. This paper examines the issues and challenges when mapping behavior models between different abstraction layers, respectively PIM and PSM using state machine models. A general solution to one of those challenges is discussed and outlined using a case study.

The rise of the number and complexity of pervasive systems is a fact. Pervasive systems developers need advanced development methods in order to build better systems in an easy way. Software Factories and the Model Driven Architecture (MDA) are two important trends in the software engineering field. This paper applies the guidelines and strategies described by these proposals in order to build a methodological approach for pervasive systems development. Software Factories are based on the definition of software families supported by frameworks. Individual systems requirements are specified by means of domain specific languages. Following this strategy, our approach defines a framework and a domain specific language for pervasive systems. We use the MDA guidelines to support the development of our domain specific language and the automatic generation of the specific source code of a particular system. The approach presented in this paper raises the abstraction level in the development of pervasive systems and provides high reusable assets to reduce the effort in the development projects.KeywordsModel TransformationGraph TransformationSoftware Product LineGraph GrammarMeeting RoomThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This paper presents a System level Model Driven Architecture (MDA) approach for power estimation of real time operating system (RTOS) communication and synchronization services at early design phases.The approach integrates the Architecture Analysis and Design Language (AADL) in the design flow. We describe how to extend the language for modeling RTOS communication and synchronization services, and we explain how power consumption analysis can be performed on software components in the AADL platform independent model (PIM), once deployed into components in the AADL target hardware platform model. Operating system services are considered as components in the MDA approach in order to take them into account in the estimation methodology. This paper focuses on consumption analysis of RTOS communication and synchronization services.

Semi-formal transformation of secure business processes into analysis class and use case models: An MDA approach

This chapter aims to present a new modeling paradigm that promises to significantly increase the efficiency of developing enterprise information systems. Currently, the software industry faces considerable challenges as it tries to build larger, more complex, software systems with fewer resources. Although modern programming languages such as C++ and Java have in general improved the software development process, they have failed to significantly increase developer’s productivity. Thus, developers are considering other paths to address this issue. One of the potential paths is designing, developing and deploying enterprise information systems using the Model Driven Architecture (MDA). MDA is a model-centric approach that allows for modeling the overall business of an enterprise and capturing requirements to developing, deploying, integrating, and managing different kinds of software components without considering any particular implementation technology. At the center of this approach are models; the software development process is driven by constructing models representing the software under development. Code that expresses the implementation of the model in a certain underlying technology is obtained as a result of model transformation. Thus, the intellectual investment spent in developing the business model of an enterprise is not jeopardized by the continuous changes of the implementation technologies. Currently there are two main approaches trying to implement MDA-based tools. One of the approaches is based on the Object Constraint Language and the other on Action Language. An example of designing, developing and deploying an application using this new modeling paradigm is presented. The MDA approach to software development is considered as the biggest shift since the move from Assembler to the first high level languages.

Recently, Peer-to-Peer (P2P) architecture is being used to explore better the computing power and bandwidth of networks than a client/server architecture. In order to support the creation of P2P applications, some frameworks were proposed such as JXTA. However, large systems using P2P architecture are complex to be developed, maintained and evolved. Model Driven Architecture (MDA) can support the management of the complexity in the software development process through transformations of Platform Independent Models (PIM) into Platform Specific Models (PSM). In this paper, we apply an MDA approach to allow the development of applications based on JXTA. The JXTA implementation in Java is used to demonstrate our approach. We propose a model transformation definition from an UML model to a Java+JXTA model. In order to validate our approach, we present two case studies.

An MDA approach for the development of data warehouses

Business corporations use frameworks and heterogeneous tools in the running of their systems. Most of these systems require the interaction between heterogeneous architectures, technologies and platforms. This integration is usually a complex task, which Model-Driven Architecture (MDA) approach to Model-Driven Software Development (MDSD) has promised to facilitate. In this paper we present a MDA-based methodology to platforms integration and show how it is successfully applied to a real business environment. In particular, the integration of three technological platforms (a framework based on Struts and J2EE, the transactional system CICS and the document manager FileNet) into a single development environment was carried out. Using this development environment, application code is 100% generated from UML-based models.KeywordsBusiness LogicApplication CodePlatform IntegrationIntegration MethodologyHeterogeneous PlatformThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.