OMG Standards Research Articles

Towards the adoption of OMG standards in the development of SOA-based IoT systems

A common feature of the Internet of Things (IoT) is the high heterogeneity, regarding network protocols, data formats, hardware and software platforms. Aiming to deal with such a degree of heterogeneity, several frameworks have applied the Model-Driven Development (MDD) to build IoT applications. On the software architecture viewpoint, the literature has shown that the Service-Oriented Architecture (SOA) is a promising style to address the interoperability of entities composing these solutions. Some features of IoT make it challenging to analyze the impact of design decisions on the SOA-based IoT applications behavior. Thus, it is a key requirement to simulate the model to verify whether the system performs as expected before its implementation. Although the literature has identified that the SOA style is suitable for addressing the interoperability, existing modeling languages do not consider SOA elements as first-class citizens when designing IoT applications. Furthermore, although existing MDD frameworks provide modeling languages comprising well-defined syntax, they lack execution semantics, thus, are not suitable for model execution and analysis. This work aims at addressing these issues by introducing IoTDraw. The framework provides a fully OMG-compliant executable modeling language for SOA-based IoT systems; thus, its specifications can be implemented by any tool implementing OMG standards.

Scaling-up domain-specific modelling languages through modularity services

Abstract Context Model-driven engineering (MDE) promotes the active use of models in all phases of software development. Even though models are at a high level of abstraction, large or complex systems still require building monolithic models that prove to be too big for their processing by existing tools, and too difficult to comprehend by users. While modularization techniques are well-known in programming languages, they are not the norm in MDE. Objective Our goal is to ease the modularization of models to allow their efficient processing by tools and facilitate their management by users. Method We propose five patterns that can be used to extend a modelling language with services related to modularization and scalability. Specifically, the patterns allow defining model fragmentation strategies, scoping and visibility rules, model indexing services, and scoped constraints. Once the patterns have been applied to the meta-model of a modelling language, we synthesize a customized modelling environment enriched with the defined services, which become applicable to both existing monolithic legacy models and new models. Results Our proposal is supported by a tool called EMF-Splitter, combined with the Hawk model indexer. Our experiments show that this tool improves the validation performance of large models. Moreover, the analysis of 224 meta-models from OMG standards, and a public repository with more than 300 meta-models, demonstrates the applicability of our patterns in practice. Conclusions Modularity mechanisms typically employed in programming IDEs can be successfully transferred to MDE, leading to more scalable and structured domain-specific modelling languages and environments.

Empowering OCL research: a large-scale corpus of open-source data from GitHub

Model-driven engineering (MDE) enables the rise in abstraction during development in software and system design. In particular, meta-models become a central artifact in the process, and are supported by various other artifacts such as editors and transformation. In order to define constraints, invariants, and queries on model-driven artifacts, a generic language has been developed: the Object Constraint Language (OCL). In literature, many studies into OCL have been performed on small collections of data, mostly originating from a single source (e.g., OMG standards). As such, generalization of results beyond the data studied is often mentioned as a threat to validity. Creation of a benchmark dataset has already been identified as a key enabler to address the generalization threat. To facilitate further empirical studies in the field of OCL, we present the first large-scale dataset of 103262 OCL expression, systematically extracted from 671 GitHub repositories. In particular, our dataset has extracted these expressions from various types of files (a.o. metamodels and model-to-text transformations). In this work we showcase a variety of different studies performed using our dataset, and describe several other types that could be performed. We extend previous work with data and experiments regarding OCL in model-to-text (mtl) transformations.

Model-based development of distributable user interfaces

The price drop of digital displays during the last decade has promoted the use of coupled-display ecosystems. This paper proposes a model-based approach to develop applications that exploit these ecosystems. It introduces the concept of Distributable User Interface to define applications running on coupled-display ecosystems that enable users to distribute interaction objects (e.g., labels, buttons, panels and frames) across interaction surfaces (e.g., Web documents, frames and panels) using a set of distribution primitives. The Distributable User Interface concept is formalized in the User Interface Distribution meta-model, which is implemented using the Eclipse Modeling Framework to ensure the compliance of these models with the OMG standards. This paper also describes the graphical model editor to create, edit and validate User Interface Distribution models conforming to the proposed meta-model. The models created with the model editor are used as input parameters for the model-to-text transformation developed in Acceleo that generates the source code of Web applications supporting Distributable User Interfaces. The generated code runs on the User Interface Distribution Framework which is also presented in this paper. Finally, the On-line Photo Gallery application is the case of study presented to demonstrate the viability of the proposal.

Considerations about quality in model-driven engineering

The virtue of quality is not itself a subject; it depends on a subject. In the software engineering field, quality means good software products that meet customer expectations, constraints, and requirements. Despite the numerous approaches, methods, descriptive models, and tools, that have been developed, a level of consensus has been reached by software practitioners. However, in the model-driven engineering (MDE) field, which has emerged from software engineering paradigms, quality continues to be a great challenge since the subject is not fully defined. The use of models alone is not enough to manage all of the quality issues at the modeling language level. In this work, we present the current state and some relevant considerations regarding quality in MDE, by identifying current categories in quality conception and by highlighting quality issues in real applications of the model-driven initiatives. We identified 16 categories in the definition of quality in MDE. From this identification, by applying an adaptive sampling approach, we discovered the five most influential authors for the works that propose definitions of quality. These include (in order): the OMG standards (e.g., MDA, UML, MOF, OCL, SysML), the ISO standards for software quality models (e.g., 9126 and 25,000), Krogstie, Lindland, and Moody. We also discovered families of works about quality, i.e., works that belong to the same author or topic. Seventy-three works were found with evidence of the mismatch between the academic/research field of quality evaluation of modeling languages and actual MDE practice in industry. We demonstrate that this field does not currently solve quality issues reported in industrial scenarios. The evidence of the mismatch was grouped in eight categories, four for academic/research evidence and four for industrial reports. These categories were detected based on the scope proposed in each one of the academic/research works and from the questions and issues raised by real practitioners. We then proposed a scenario to illustrate quality issues in a real information system project in which multiple modeling languages were used. For the evaluation of the quality of this MDE scenario, we chose one of the most cited and influential quality frameworks; it was detected from the information obtained in the identification of the categories about quality definition for MDE. We demonstrated that the selected framework falls short in addressing the quality issues. Finally, based on the findings, we derive eight challenges for quality evaluation in MDE projects that current quality initiatives do not address sufficiently.

Model-driven Java code refactoring

Refactoring is an important technique for restructuring code to improve its design and increase programmer productivity and code reuse. Performing refactorings manually, however, is tedious, time consuming and error-prone. Thus, providing an automated support for them is necessary. Unfortunately even in our days, such automation is still not easily achieved and requires formal specifications of the refactoring process. Moreover, extensibility and tool development automation are factors that should be taken into consideration when designing and implementing automated refactorings. In this paper, we introduce a model-driven approach where refactoring features, such as code representation, analysis and transformation adopt models as first-class artifacts. We aim at exploring the value of model transformation and code generation when formalizing refactorings and developing tool support. The presented approach is applied to the refactoring of Java code using a prototypical implementation based on the Eclipse Modeling Framework, a language workbench, a Java metamodel and a set of OMG standards.

NMMp: A Model-Driven UML Extension for the Description of Navigation Maps for Web Applications

With the advent of multitier and service-oriented architectures, the presentation tier is more detached from the rest of the web application than ever. Moreover, complex web applications can have thousands of linked web pages built using different technologies. As a result, the description of navigation maps has become more complex in recent years. This paper presents NMMp, a UML extension that: (i) provides an abstract vision of the navigation structure of the presentation tier of web applications, independently of architectural details or programming languages; (ii) can be automatically transformed into UML-WAE class diagrams, which can be easily integrated with the design of the other tiers of the web application; (iii) encourages the use of architectural and multitier design patterns; and (iv) has been developed according to OMG standards, thus facilitating its use with general purpose UML CASE tools in industry.

Extracting business vocabularies from business process models: SBVR and BPNM standards-based approach

Approaches for the analysis and specification of business vocabularies and rules are relevant topics in both Business Process Management and Information Systems Development disciplines. However, in common practice of Information Systems Development, the Business modeling activities still are of mostly empiric nature. In this paper, aspects of the approach for semi-automatic extraction of business vocabularies (BV) from business process models (BPM) are presented. The approach is based on novel business modeling-level OMG standards ?Business Process Model and Notation? (BPMN) and ?Semantics for Business Vocabularies and Business Rules? (SBVR), thus contributing to OMG?s vision of Model-Driven Architecture (MDA) and to model-driven development in general. The discussed extraction approach is evaluated against fully-automatic BPMN BPM ? SBVR BV transformation that has been developed in parallel to the presented work.

An Approach for Extracting Business Vocabularies from Business Process Models

Being a part of business process management (BPM) life cycle, business process modeling has found its place in information systems development (ISD) practices as well. At the same time, concepts of business vocabularies and rules are also the hot topics among BPM and ISD practitioners and academics. Nevertheless, in ISD, the integration of business process models with business vocabularies and rules is still not standardized and remains quite empiric. In this paper, basic aspects of the approach for business vocabularies’ extraction from business process models are presented. The approach is based on novel business level OMG standards “Business Process Model and Notation” (BPMN) and “Semantics for Business Vocabularies and Business Rules” (SBVR), thus contributing to OMG’s vision about Model-Driven Architecture (MDA) and to model-driven development in general.DOI: http://dx.doi.org/10.5755/j01.itc.42.2.2310

Automated generation of test oracles using a model-driven approach

ContextSoftware development time has been reduced with new development tools and paradigms, testing must accompany these changes. In order to release software products in a timely manner as well as to minimise the impact of possible errors introduced during maintenance interventions, testing automation has become a central goal. Whilst research has produced significant results in test case generation and tools for test case (re)-execution, one of the most important open problems in testing is the automation of oracle generation. The oracle decides whether the program under test has or has not behaved correctly and then issues a pass/fail verdict. In most cases, writing the oracle is a time-consuming activity that, moreover, is manual in most cases. ObjectiveThis article automates two important steps in the test oracle: obtention of expected output and its comparison with the actual output, using a model-driven approach. MethodThe oracle automation problem is resolved using a model-driven framework, based on OMG standards: UML is used as metamodel and QVT and MOF2Text as transformation languages. The automated testing framework takes the models that describe the system as input, using UML notation and derives from them the test model and then the test code, following a model-driven approach. Test oracle procedures are obtained from a UML state machine. ResultsA complete executable test case at functional test level is obtained, composed of a test procedure with parametrized input test data and expected result automation. ConclusionThe oracle automation is obtained using a model-driven approach, test cases are obtained automatically from UML models. The model-driven testing framework was applied to an industrial application and has been useful to testing automation for the main functionalities in the system.

Object constraint language (OCL)

OCL was introduced as a part of UML in 1997 as a business modeling language by IBM. Ever since its inception, the actual use of OCL in the industry has been almost negligible, even amongst the business application development community, for which it was specifically created. But now with the inception of MDA and related OMG standards the role of OCL is changing. UML 2.0 has introduced new concepts and refined some other including OCL in a way that UML 2.0 is now almost software architectures conformant too. This paper makes an investigation into the recent developments and explores the role of OCL in the current scenario and its future applications.

On Foundation for Certification of Model Driven Architecture (MDA) Tools: Defining a Specification

A modern approach to software development inclu- des a wide variety of processes, which are used to regulate and manage the entire development life cycle. One of th e main aspects to be considered during the preparation stage of so ftware development is the selection of the right tools. No wadays when software systems become more and more complex, an inappropriate selection of the tools may cause proj ect not to succeed at all. That is why the main challenge of th e industry is still aimed on the simplification, optimization, an d automation of software development process. One of the ways to deal with an increasing complexity, as well as not to dig into t he details of the source code, is to use modeling. A model-driven approach, mainly represented by OMG's Model Driven Architecture as the most advanced and popular one, purports to be the next evolutional milestone for the whole software industry. In fact, most of the tools currently available on the market are claimed as complaint, though have never been checked or analyzed for that compliance. Therefore, there should be a certificat ion program defined to figure out the main features of each too l in accordance with OMG standards. The original article proposes a foundation for certification of MDA tools. In particular, this includes the specification of the most common features and optio ns defined to clarify the accordance level of each tool from vari ous perspectives.

Mandatory and Discretionary Policies for CORBA Security

This paper proposes extending the CORBA (Common Object Request Broker Architecture) security model to make possible the use of mandatory policies and policy management in distributed applications. Mandatory policies and a policy service were proposed for insertion in the JaCoWeb Project, which is developing an authorization scheme for large-scale networks based on CORBA security standards. In this paper, there is a combination of client-side and server-side access control, in a single domain. Our mandatory control is carried out on the level of ORB (Object Request Broker), on the client side, preventing, in unauthorized accesses, the emission of the corresponding requisition, the associated processing on the server and also, the generation of new requests through this unauthorized processing. In this paper, operations of security management not currently included in the OMG standards are also proposed. The paper further presents implementation results and an evaluation of these results based on common criteria.

On the unification power of models

In November 2000, the OMG made public the MDA™initiative, a particular variant of a new global trend called MDE (Model Driven Engineering). The basic ideas of MDA are germane to many other approaches such as generative programming, domain specific languages, model-integrated computing, generic model management, software factories, etc. MDA may be defined as the realization of MDE principles around a set of OMG standards like MOF, XMI, OCL, UML, CWM, SPEM, etc. MDE is presently making several promises about the potential benefits that could be reaped from a move from code-centric to model-based practices. When we observe these claims, we may wonder when they may be satisfied: on the short, medium or long term or even never perhaps for some of them. This paper tries to propose a vision of the development of MDE based on some lessons learnt in the past 30 years in the development of object technology. The main message is that a basic principle ("Everything is an object") was most helpful in driving the technology in the direction of simplicity, generality and power of integration. Similarly in MDE, the basic principle that "Everything is a model" has many interesting properties, among others the capacity to generate a realistic research agenda. We postulate here that two core relations (representation and conformance) are associated to this principle, as inheritance and instantiation were associated to the object unification principle in the class-based languages of the 80's. We suggest that this may be most useful in understanding many questions about MDE in general and the MDA approach in particular. We provide some illustrative examples. The personal position taken in this paper would be useful if it could generate a critical debate on the research directions in MDE.

A toolkit for model manipulation

We present a toolkit to develop scripts to process software models. It can be used to create applications to check, transform and generate derived artifacts from a model. The toolkit is based on the current OMG standards and it can be used with the Unified Modeling Language (UML) and other user-defined languages based on the Meta Object Facility.