Narrow Results

Usability is currently a key feature for developing quality systems. A system that satisfies all the functional requirements can be strongly rejected by end-users if it presents usability problems. End-users demand intuitive interfaces and an easy interaction in order to simplify their work. The first step in developing usable systems is to determine whether a system is or is not usable. To do this, there are several proposals for measuring the system usability. Most of these proposals are focused on the final system and require a large amount of resources to perform the evaluation (end-users, video cameras, questionnaires, etc.). Usability problems that are detected once the system has been developed involve a lot of reworking by the analyst since these changes can affect the analysis, design, and implementation phases. This paper proposes a method to minimize the resources needed for the evaluation and reworking of usability problems. We propose an early usability evaluation that is based on conceptual models. The analyst can measure the usability of attributes that depend on conceptual primitives. This evaluation can be automated taking as input the conceptual models that represent the system abstractly.

Among the various steps in the life cycle of software development, system requirement management is an essential but often neglected step. Comprehensive requirement management can not only help developers to work on a system to meet the requirements of a project, but can also play a vital role in the communications among stakeholders. In general, natural languages are often used to describe and record user requirements; however, this results in ambiguity, inconsistency, imprecision and incompleteness. To increase the accuracy of requirement modeling and analysis, it is important to have appropriate management methods and tools such that the requirement engineering process can be supported within the project. In this work, we propose a System Modeling Language (SysML)-based requirement management methodology to assist in the collection and the modeling of user requirements. We also provide a convenient procedure and a prototype tool to model, analyze, validate and verify the recorded system requirements, and consequently to ensure that the system can satisfy users’ requirements.

Cyber-physical systems (CPSs) are pervasive in our daily life from mobile phones to auto-driving cars. CPSs are inherently complex due to their sophisticated behaviors and thus difficult to build. In this paper, we propose a framework to develop CPSs based on a model-driven approach with quality assurance throughout the development process. An agent-oriented approach is used to model individual physical and computation processes using high-level Petri nets, and an aspect-oriented approach is used to integrate individual models. The Petri net models are systematically mapped to classes and threads in Java, which are enhanced and extended with domain-specific functionalities. Complementary quality assurance techniques are applied throughout system development and deployment, including simulation and model checking of design models, model checking of Java code, and runtime verification of Java executable. We demonstrate our framework using a car parking system.

Model refactoring enhances the platform-independent design models of software aiming at smoother impact of requirement changes, thereby improving the design quality and assisting in their evolution and maintenance. This study reports a systematic literature review of refactoring techniques particularly in the domain of models of object-oriented software systems. The study used the standard systematic literature review method based on a comprehensive set of 58 articles from a total of 1200 articles published in leading journals, premier conferences, workshops and books. The primary studies were thoroughly analyzed on various aspects of model refactoring process. Identification of methodologies and classification on the basis of model transformation systems, refactoring operations and their application, model behavior specification and preservation, model quality expression, model consistency management and automation of process is reported. This study shows that inadequate model-based approaches for behavior preservation, synchronized model enhancement and empirical evaluation of the proposed refactoring techniques are major obstacles in fully automated model refactoring process.

Model transformation is a keystone in carrying out model-driven development. Currently, many studies have focused on model transformation, those researches study the automatic transformation from PIM to PSM and from PSM to code, but only few have dealt with how the CIM-level model is automatically mapped onto the PIM-level model. Even though some studies have proposed the semi-automatic transformation from CIM-level model to PIM-level model, only few mechanisms are discussed to protect the consistency between the CIM-level model and the PIM-level model in these researches because notation specification of these CIM-level model and PIM-level model does not contain precise semantics. Focusing on workflow perspective, this paper proposes an automatic model transformation approach, which applies a formal model to define the automatic mapping of the workflow from CIM-level model to PIM-level model. This proposal extends Petri nets model elements to define a bridge model, then we use this bridge model to link the CIM-level model (BPMN) and PIM-level model (SCM) following model-driven approach. The metamodels, the transformation rule and the transformation plug-ins have been defined in Eclipse Modeling Framework. Meanwhile, the plug-ins have been empirically validated by a Travel Agency case study. This study shows that using extended Petri nets model as a bridge model to define an automatic model transformation between CIM-level model and PIM-level model is feasible. This approach by means of formal model can ensure the correctness and completeness of the target model, and it can also maintain the consistency between the source model and target model.

Virtual Organizations are a mechanism where agents can demonstrate their social skills since they can work in a cooperative and collaborative way. Nonetheless, the development of organizations using Multi-Agent Systems (MAS) requires extensive experience in different methodologies and platforms. Model-Driven Development (MDD) is a technique for generating application code that is developed from basic models and meta-models using a variety of automatic transformations. This paper presents an approach to develop and deploy organization-oriented Multi-Agent Systems using a model-driven approach. Based on this idea, we introduce a relatively generic agent-based meta-model for a Virtual Organization, which was created by a comprehensive analysis of the organization-oriented methodologies used in MAS. Following the MDD approach, the concepts and relationships obtained were mapped into two different platforms available for MAS development, allowing the validation of our proposal. In this way, the resultant approach can generate Virtual Organization deployments from unified meta-models, facilitating the development process of agent-based software from the user point of view.

If e-business contracts are to be widely used, they need to be supported by the IT infrastructure of the organizations concerned. This implies that the interactions between systems in different organizations must be guided by the contract and there must be sufficiently strong checks and balances to ensure that the contract is in fact obeyed. This includes facilities for the unbiased monitoring of correct behaviour and the reporting of exceptions.

One of the ways to provide this support is to generate it directly from the agreed contract. This paper considers the steps necessary to provide sufficient automation in the support and checking of e-Business contracts for them to offer efficiency gains and so to become widely used. It focuses on the role of models, taking a model-driven approach to development and discussing both the source and target models and the transformational pathways needed to support the contract-based business processes.

We describe a method based on UML activities for the unified specification of collaborative service behavior and local user interfaces. The method enables a model-driven development process, which effectively combines the need to express service collaborations involving several components with the need to provide detailed operations for user interfaces. Our service models use activities as the primary building blocks that encapsulate self-contained functionalities. We show, how a complete distributed system can be decomposed into such building blocks, how this decomposition leads to a separation of user interface concerns from service collaboration concerns, and how they may be combined with an event-driven composition mechanism based on activity parameter nodes. We also demonstrate how different UI frameworks can be supported, and illustrate the method with a case study of a situated collaborative learning service.

Model-driven development is recognized as one of the most promising approaches in software engineering. Recent research in the area highlights the importance of using an explicit architectural model in this context. Since service-oriented architectures have also demonstrated to be adequate to overcome current software needs, the idea of using the model-driven approach to generate service-oriented architectural models has successfully flourished in the last years. However, the emphasis on the Service-Oriented Computing (SOC) paradigm has led to the design of architectures lacking some desirable features. Knowing the benefits provided by architectural styles, we have found that their use can help us to overcome those needs. Our goal is to obtain a service-oriented model which satisfies the requirements of the concrete architecture and complies with the constraints and vocabulary defined for a specific architectural style. To achieve this, here, we propose to use a weaving model which merges the concrete architectural model with a model of the architectural style of choice.

Workflow monitoring and analysis concerns aim at identifying potential improvements of workflow applications. This paper presents an approach to specify and implement monitoring and analysis concerns on workflow applications raising the level of abstraction for workflow analysts. First, the specification of monitoring and analysis concerns is declared in a technology-independent way with a domain-specific language named MonitA. MonitA makes extensive use of the data available in the workflow application and its constituents to enhance the monitoring and analysis specifications. Second, we defined and implemented a strategy to assist developers to enhance a given workflow technology to support the generation of the monitoring and analysis code and its composition with the workflow application. This instrumentation-based approach enables the monitoring and analysis of workflow applications during their operational execution. We illustrate the flexibility of our approach by targeting different workflow platforms and different workflow applications.

Recent research on Software Architecture has recovered its original emphasis on keeping track of design decisions and their rationales during software development, compiling them under the name of architectural knowledge (AK). This knowledge is composed of decision assets, which relate to each other creating a decision network structure. We argue that relationships in these networks of AK contain valuable information, in particular when they describe negative semantics. We use antipatterns to exploit and manage these negative relationships systematically. After examining and classifying the kinds of AK relationships, we describe a method that enriches this network by means of antipattern structures. To show the feasibility and suitability of this approach, we provide a proof-of-concept by applying it to an existing process, ATRIUM, with a concrete example, the Gas Station metaphor. Results of the use of the presented approach into three different projects with different complexities show both its feasibility and applicability.

Due to the large and complex nature of the Internet of Things (IoT), various analysis and design methodologies are proposed. Design pattern is one of them to provide the solution for a design problem, which is recurring in nature. In this approach, we have presented design patterns for the IoT use cases such as service integration and IoT security. But the semi-formal nature of software patterns may lead to bugs in the proposed pattern. Hence, an ontology-based approach is considered for modelling of the IoT design patterns. Further, we have presented an ontology-based framework for the specification and refinement of IoT design patterns. In this approach, an analysis of meta-models and ontologies has also been performed for reducing the gap between high-level design abstraction of Unified Modeling Language (UML)-based IoT patterns and formal ontology.

Genetic programming (GP) is known to provide good solutions for many problems like the evolution of network protocols and distributed algorithms. In most cases it is a hardwired module of a design framework assisting the engineer in optimizing specific aspects in system development. In this article, we show how the utility of GP can be increased remarkably by isolating it as a component and integrating it into the model-driven software development process. Our GP framework produces XMI-encoded UML models that can easily be loaded into widely available modeling tools, which in turn offer code generation as well as additional analysis and test capabilities. We use the evolution of a distributed election algorithm as an example to illustrate how GP can be combined with model-driven development (MDD).

Late detection of new types of faults often results in the evolution of fault-tolerance requirements while developers have already created design artifacts. Thus, the reuse of an existing design in the development of a fault-tolerant version thereof has the potential to reduce the overall development costs. Moreover, the automation of such a reuse yields a fault-tolerant design that is correct by construction, given that the existing design is correct. To facilitate such an automation, we present an approach, where we add three levels of fault-tolerance, namely failsafe, nonmasking, and masking, to functional designs represented as state machines. Intuitively, failsafe fault-tolerance requires that safety specification is met even in the presence of faults. In the presence of faults, nonmasking fault-tolerance guarantees recovery to states from where safety and liveness specifications are satisfied. Masking fault-tolerance stipulates that (i) recovery is provided to states from where safety and liveness specifications are met, and (ii) safety specification is satisfied during such a recovery. Specifically, we present sound and complete deterministic algorithms for automated addition of (failsafe/nonmasking/masking) fault-tolerance to the functional design of concurrent programs. These polynomial-time algorithms are especially useful in model-driven development of fault-tolerant systems, where models are automatically checked and modified. We also discuss (1) the effect of distribution and safety specification model on the complexity of adding fault-tolerance, and (2) the impact of the proposed algorithms on the addition of multitolerance.