Combining Tools to Design and Develop Software Support for Capabilities

Model-Driven Development (MDD) is becoming increasingly popular as a choice for developing information systems. Tools that support the principles of MDD are also growing in number and variety of available functionality. MetaEdit+ is a meta-modeling tool used for developing Domain Specific Languages and is identified as an MDD tool. The Eclipse Modeling Framework (EMF) and Graphical Modeling Project (GMP) are two Eclipse projects that provide plug-ins to support the principles of MDD. In this paper, we report on our experience in using MetaEdit+ and the Eclipse plug-ins for developing a graphical editor for the unifying meta-model, which is an MDD approach that extends the traditional view of MDD to cover Enterprise Modeling. The two modeling environments are reviewed using quality areas that are identified by the research community as necessary in MDD tools. This report will provide useful insights for researchers and practitioners alike concerning the use of MetaEdit+ and the Eclipse plug-ins as MDD tools.

Capability-driven development (CDD) is a novel paradigm for organisational modelling and information technology development. Its cornerstones are capability modelling (including goals, context, processes), pattern-based design, and runtime context awareness and service delivery adjustment. There is a lack of empirical studies regarding the industrial application of CDD. This paper reports on a case study that focuses on capability modelling within a service-oriented architecture development project. We have collected lessons learned, as well as open challenges to feedback the improvement of the CDD methodology.

Model Driven Architectures and Model Driven Development (MDD) have been used in information system (IS) development projects for almost a decade. While the methodological support for the MDD process is important, the success of a project taking the model driven approach to development also heavily depends on the tool. The tool simply needs to support a set of key functionalities, such as an appropriate level of model abstraction, the refinement of models and finally the execution of models. In this paper we analyze a new MDD tool, namely Mendix, with respect to a number of functionality areas needed to achieve success in a project and capitalize on the benefits of MDD. Our findings are that Mendix use a well selected set of models and that these models are well integrated and suitable for the construction of small systems. Based on the key functionality areas we also point out the weaknesses of the tool.KeywordsModel Driven ArchitectureModel Driven DevelopmentMDDCASE tools

Most modeling approaches lack in their ability to cover a full-fledged view of a software system’s business requirements, goals, and capabilities and to specify aspects of flexibility and variability. The modeling language Capability Driven Development (CDD) allows modeling capabilities and their relation to the execution context. However, its context-dependency lacks the possibility to define dynamic structural information that may be part of the context: persons, their roles, and the impact of objects that are involved in a particular execution occurrence. To solve this issue, we extended the CDD method with the BROS modeling approach, a role-based structural modeling language that allows the definition of context-dependent and dynamic structure of an information system. In this paper, we propose the integrated combination of the two modeling approaches by extending the CDD meta-model with necessary concepts from BROS. This combination allows for technical development of the information system (BROS) by starting with capability modeling using CDD. We demonstrate the combined meta-model in an example based on a real-world use case. With it, we show the benefits of modeling detailed business requirements regarding context comprising environment- and object-related information.

Companies need to rethink business processes, infrastructures, technologies, staff, etc. according to new demands, strategic goals, and changes in their environment. Information System evolution has been supported by the reengineering process. Since the models are now part of an increasing number of engineering processes and model-driven software development is a well-established paradigm to support information systems, the reengineering process could be improved with the incorporation of the model-driven development paradigm. This paper presents a model-driven organisational reengineering framework to support organisational improvement. The main idea is to get the most out of the existing proposals in model-driven development for the reengineering process (reverse engineering, improvement processes, and forward processes). Methods, techniques, model-driven tools, and perspectives for analysing information systems at a high level of abstraction are presented as a part of this proposal. A reference framework for the reengineering process is established to provide a consistent set of concepts that support the proposed framework. An illustrative example is introduced to present the feasibility of the proposal. The example illustrates the SuperStationery Co. case in order to present a reengineering process to align an existing desk application with a web application that fulfils the strategic goals of the company. Finally, we conclude with an analysis and discussion about lessons learned and future works.

Model Driven Development (MDD) requires proper tools to derive the implementation code from the application models. However, the integration of handwritten and generated code is a long-standing issue that affects the adoption of MDD in the industry. This article presents a model and code co-evolution approach that addresses such a problem a posteriori , using the standard collision detection capabilities of Version Control Systems to support the semi-automatic merge of the two types of code. We assess the proposed approach by contrasting it with the more traditional template-based, forward-engineering process, adopted by most MDD tools.

The usage of models within model-driven software development aims at facilitating complexity management of the system under development and closing the gap between the problem and the solution domain. Utilizing model-driven software development (MDD) tools for agile development can also increase the complexity within a project. The huge number of different artifacts and relations, their different kinds, and the high degree of automation hinder the understanding, maintenance, and evolution within MDD projects. A systematic approach to understand and manage MDD projects with a focus on its artifacts and corresponding relations is necessary to handle the complexity. The artifact-based analysis presented in this paper is such an approach. This paper gives an overview of different contributions of the artifact-based analysis but focuses on a specific kind of analysis: architecture consistency checking of model-driven development projects. By applying this kind of analyses, differences between the desired architecture and the actual architecture of the project at a specific point in time can be revealed.

In many development projects models are core artifacts used to generate concrete implementations from them. However, for many systems it is impossible or not useful to generate the complete software system from models alone. Hence, developers need mechanisms for integrating generated and handwritten code. Applying such mechanisms without considering their effects can cause issues in projects, where model and code artifacts are essential. Thus, a sound approach for the integration of both forms of code is needed. In this paper, we provide an overview of mechanisms for integrating handwritten and generated object-oriented code. To compare these mechanisms, we define and apply a set of criteria. The results are intended to help model-driven development (MDD) tool developers in choosing an appropriate integration mechanism. In this extended version, we additionally discuss essential integration aspects including the protection of generated code and elaborate on how to use action languages to extend generated code.

In real world, most business processes are subject to time constraints. Equally important as the execution of a process is the time in which it is to be performed. A time constrained business process can be defined as a process whose correct behavior depends not only on the results obtained, but also on the time it is carried out. UML has become an important tool for model-driven software development, perhaps partly thanks to its visually oriented modeling concepts, and it is increasingly being used in business process modeling too. In this paper, we extend UML 2.0 Activity Diagrams with time annotations and new modelling constructs inspired of the Timed CSP language. Furthermore, in order to overcome the lack of formal semantics that these diagrams suffer from, we introduce a set of mapping rules to derive formal specifications in terms of Timed CSP processes from models in the extended Activity Diagrams being proposed. Timed CSP has several features that make it well suited to give a formal semantics for extended Activity Diagrams (e.g., compositionality, well defined denotational and operational semantics, etc.). The proposed mapping rules enable checking whether the model described in an Activity Diagram satisfies such properties as timeliness, deadlock freeness, liveness, etc. In order to show the applicability of our approach, we present a case study from a manufacturing domain.

Developing multi-purpose Human Language Technologies (HLT) pipelines and integrating them into the large scale software environments is a complex software engineering task. One needs to orchestrate a variety of new and legacy Natural Language Processing components, language models, linguistic and encyclopedic knowledge resources. This requires working with a variety of different APIs, data formats and knowledge models. In this paper, we propose to employ the Model Driven Development (MDD) approach to software engineering, which provides rich structural and behavioral modeling capabilities and solid software support for model transformation and code generation. These benefits help to increase development productivity and quality of HLT assets. We show how MDD techniques and tools facilitate working with different data formats, adapting to new languages and domains, managing UIMA type systems, and accessing the external knowledge bases.

User interface prototypes are effective structure for describing as models for web application development thanks to their graphical and dynamic architecture. It provides the benefits such as language independent development, less error-prone and increased quality. The executable programming codes are created by code transformation feature of model-driven development tools as well. Nevertheless, this technique brings the problems along all its benefits. First of all, code transformation from user interfaces by development tools, creates complicated structure to analyze and modify. Another challenge is to deal with the processes which are triggering each other. In addition, data connected process adaptation is a problem as well. All these issues eventually require the integration of discrete modules. This study provides not only a proposal structure to deal with integration problem in web development, but also provides the evaluation criteria for classification of the integration processes.

Conference proceedings front matter may contain various advertisements, welcome messages, committee or program information, and other miscellaneous conference information. This may in some cases also include the cover art, table of contents, copyright statements, title-page or half title-pages, blank pages, venue maps or other general information relating to the conference that was part of the original conference proceedings.

Content management systems (CMSs) such as Joomla and WordPress dominate today’s web. Enabled by standardized extensions, administrators can build powerful web applications for diverse customer demands. However, developing CMS extensions requires sophisticated technical knowledge, and the complex code structure of an extension gives rise to errors during typical development and migration scenarios. Model-driven development (MDD) seems to be a promising paradigm to address these challenges; however, it has not found adoption in the CMS domain yet. Systematic evidence of the benefit of applying MDD in this domain could facilitate its adoption; however, an empirical investigation of this benefit is currently lacking. In this paper, we present a mixed-method empirical investigation of applying MDD in the CMS domain, based on an interview suite, a controlled experiment, a field experiment, and case studies. During the experiments, we used JooMDD, an MDD infrastructure instantiation for CMS extensions. This infrastructure, which is also presented in this work, consists of a DSL with model editors, code generators, and reverse engineering facilities. We consider three scenarios of developing new (both independent and dependent) CMS extensions and of migrating existing ones to a new major platform version. The experienced developers in our interviews acknowledge the relevance of these scenarios and report on experiences that render them suitable candidates for a successful application of MDD. We found a particularly high relevance of the migration scenario. Our experiments largely confirm the potentials and limits of MDD as identified for other domains. In particular, we found a productivity increase up to factor 11.7 and a quality increase up to factor 2.4 during the development of CMS extensions. Furthermore, our observations highlight the importance of good tooling that seamlessly integrates with already used tool environments and processes.

The paper examined the problem of modeling and design of software computer systems. The article briefly describes the content aspects of the various stages of the implementation of software complexes and systems. The methodology of research and analysis of systems, which uses the method of computer simulation modeling, is given. The aim of the work is to create a new universal approach to the design and implementation of software systems of various levels of complexity. During the study, the following general scientific methods were used: system analysis, synthesis, formalization, modeling, decomposition, structuring, description, comparison. The materials used in the study were: computers and software development tools. As a result of the study proposed a universal agent-module approach to the design and implementation of software systems based on simulation agent-based modeling. The study presents the processes of modeling and designing software systems, their stages, and the possibility of their integration within the described approach. Examples of formal model and structure of the software system under design based on the agent-module approach are presented. The proposed approach can be used in the process of software development at the initial stages related to modeling and designing of software systems. Integration of modeling and design stages in the proposed approach will significantly reduce software development time and simplify the design process by making it clearer and more formalized. Materials of the article are of scientific and practical value for a wide range of specialists interested in system analysis, modeling, design and implementation of software systems.

Over the last few years organizations have been dealing with the integration of their business processes and software and technologies to support their realization. One challenge is to unite the vision from business and software areas, to design and implement business processes in a way that allows organizations to react agilely to changes. New paradigms have appeared to support this vision: Business Process Management (BPM), Service-Oriented Computing (SOC) and Model-Driven Development (MDD). BPM deals with managing business process lifecycle from modeling, implementation, execution and evaluation to find improvement opportunities. SOC bases the design and implementation of software on services, which are defined to support business processes. MDD focus is on models, allowing the definition of automatic transformation between them along with code generation for different platforms. In this article we present the main principles for the integration of these paradigms as found in a systematic review carried out with the objective of establishing the bases for our research.KeywordsBusiness process management (BPM)Service-oriented computing (SOC)Model-driven development (MDD)Systematic review