A Formal Model Driven Approach to Dependable Software Evolution

The management of software evolution as well as the maintenance of its complexity is of two most important problems to be solved by software engineering. Several solutions have been considered, one of them being the separation of concerns. These concepts have been extended along the life cycle of software development and thus, aspect oriented software development (AOSD) arose and shed new light on software evolution problems. In this paper we focus on the seamless integration of AOSD and software architecture to support dynamic software evolution in architecture level. Thus we propose an incremental aspect-oriented (AO) architecture modeling approach. In the approach we introduce a unified formal model, namely aspect weaving connector (AWC), to formalize the underlying mechanisms of aspect dynamic weaving in architecture level. Meanwhile, we introduce a simple and seamless extension of ACME ADL to support the modular representation of architectural aspects, components, AWC and their composition forms. For the unified connector model has been applied in our implemented framework for dynamic software architecture, a case study on adaptive JPS (Java pet store) is illustrated to show the advantages of this approach and the unified model.

Model transformations are frequently used means for automating software development in various domains to improve quality and reduce production costs. Debugging of model transformations often necessitates identifying parts of the transformation program and the transformed models that have causal dependence on a selected statement. In traditional programming environments, program slicing techniques are widely used to calculate control and data dependencies between the statements of the program. Here we introduce program slicing for model transformations where the main challenge is to simultaneously assess data and control dependencies over the transformation program and the underlying models of the transformation. In this paper, we present a dynamic backward slicing approach for both model transformation programs and their transformed models based on automatically generated execution trace models of transformations.

Many companies in the automotive industry have adopted model-driven development in their vehicle software development. As a major automotive company, General Motors (GM) has been using a custom-built, domain-specific modeling language, implemented as an internal proprietary metamodel, to meet the modeling needs in its control software development. Since AUTomotive Open System ARchitecture (AUTOSAR) has been developed as a standard to ease the process of integrating components provided by different suppliers and manufacturers, there has been a growing demand to migrate these GM-specific, legacy models to AUTOSAR models. Given that AUTOSAR defines its own metamodel for various system artifacts in automotive software development, we explore applying model transformations to address the challenges in migrating GM-specific, legacy models to their AUTOSAR equivalents. As a case study, we have built and validated a model transformation using the MDWorkbench tool, the Atlas Transformation Language, and the Metamodel Coverage Checker tool. This paper reports on the case study, makes observations based on our experience to assist in the development of similar types of transformations, and provides recommendations for further research.

Recent technologies have cleared the way for large scale application of electronic communication. The open and distributed nature of these communications implies that the communication medium is no longer completely controlled by the communicating parties. As a result, there has been an increasing demand for research in establishing secure communications over insecure networks, by means of security protocols. In this thesis, a formal model for the description and analysis of security protocols at the process level is developed. At this level, under the assumption of perfect cryptography, the analysis focusses on detecting aws and vulnerabilities of the security protocol. Starting from ??rst principles, operational semantics are developed to describe security protocols and their behaviour. The resulting model is parameterized, and can e.g. capture various intruder models, ranging from a secure network with no intruder, to the strongest intruder model known in literature. Within the security protocol model various security properties are de??ned, such as secrecy and various forms of authentication. A number of new results about these properties are formulated and proven correct. Based on the model, an automated veri??cation procedure is developed, which signi ??cantly improves over existing methods. The procedure is implemented in a prototype, which outperforms other tools. Both the theory and tool are applied in two novel case studies. Using the tool prototype, new results are established in the area of protocol composition, leading to the discovery of a class of previously undetected attacks. Furthermore, a new protocol in the area of multiparty authentication is developed. The resulting protocol is proven correct within the framework.

Model-driven engineering (MDE) promises faster and more reliable software development processes. A key factor of MDE is the transformation of models, allowing a software engineer to use the most appropriate modeling notation for a particular task. The earlier transformations can be applied during software development, the greater the potential cost savings. To that effect, we report on the transformation of aspect-oriented models for reactive systems development, i.e., from a scenario-based requirements model into a UML-based design model. We use Aspect-oriented Use Case Maps (AoUCM) as the requirements notation and Reusable Aspect Models (RAM) as the design notation. While AoUCM is ideally suited for the specification of the system workflow comprised of interactions between the environment and the system, RAM excels in providing a design view of system structure and defining the data dimension of the system including inputs and outputs. As the more abstract AoUCM models are transformed into more concrete RAM models, MDE ensures that the AoUCM workflow specifications do not have to be modeled again in RAM, thus avoiding a duplication of effort. We present transformation algorithms to show that an AoUCM-to-RAM mapping is indeed feasible and report on initial tool support for the transformation.

Software reuse and evolution are problematic. Modules tend to express a great deal of knowledge about the external modules, large-scale structure, and behaviour of the systems in which they reside. As a result, the reusability of individual modules is decreased as they are too dependent on other modules. Likewise, the evolvability of systems is decreased as they are too dependent on the details of individual modules. However, we must have some dependences between our modules, or they would not be able to operate together. Not all dependences are equally bad, then. Each module can be seen to have a minimal core, an essential structure, beyond which it makes no sense to reduce. This essential structure describes the basic responsibilities of that module, and its expectations of the responsibilities of external modules. The thesis of this dissertation is that expressing the essential structure of our software modules, through the use of implicit context, makes those modules easier to reuse and the systems containing those modules easier to evolve. Implicit context revolves around the notion that we must abandon the need for all modules to be defined with respect to an absolute frame of reference. Instead, modules can be defined relative to a reference frame of convenience. In order for modules to work together, the inconsistencies in their independent world views must be reconciled when they attempt to communicate. Implicit context provides the novel mechanism of contextual dispatch to perform this reconciliation. When any communication passes into or out of a module, that communication may be rerouted, altered, replaced, or discarded altogether, as the situation dictates. This translation process sometimes requires access to information about the communication history of the system; objects previously passed can be retrieved, or the appropriate recipient of a message can be determined. The dissertation describes a prototype tool that supports the application of implicit context to Java source code. The thesis is validated by applying this tool in two case studies: comparing the evolution of an implicit context-based implementation of an FTP server to an object-oriented implementation; and reusing the Outline View of the Eclipse integrated development environment in a different application, even though the Outline View was not designed for such reuse.

In recent years, the availability and use of prototyping and usability testing tools has increased massively in practice. In parallel, research introduced multiple novel approaches and tools to assist novice and expert designers in prototyping. However, existing research has not looked into how to assist designers in conducting usability tests and making the collected quantitative data directly available in prototyping tools. In this paper, we distill three design goals from literature and propose a novel quantitative test-driven prototyping approach. The approach in its current form consists of a process and two user interface artifacts supporting selected actions of our process. We conducted a formative study to gather feedback from potential users on our approach. We use the collected feedback to refine our approach, identify trade-offs, and propose future research directions. We contribute by providing a novel quantitative test-driving prototyping approach that tightly connects prototyping with asynchronous usability testing.

We introduce a formal language for specifying dynamic updates for Software Defined Networks. Our language builds upon Network Kleene Algebra with Tests (NetKAT) and adds constructs for synchronisations and multi-packet behaviour to capture the interaction between the control- and data-plane in dynamic updates. We provide a sound and ground-complete axiomatisation of our language. We exploit the equational theory and provide an efficient method for reasoning about safety properties. We implement our equational theory in DyNetiKAT – a tool prototype, based on the Maude Rewriting Logic and the NetKAT tool, and apply it to a case study. We show that we can analyse the case study for networks with hundreds of switches using our tool prototype.

Model transformation is a crucial aspect of Model-Driven Software Development. With the help of model transformation, we can generate source code or other models from software models. However, a recurring problem in software development is the fact that source and target models coexist and they evolve independently. This means that after the initial transformation phase the target models are often changed by the developers and the target model will no longer be consistent with the source model. Therefore, the models need to be synchronized. Model transformation is one option to implement the synchronization process. However, it is very complex because the transformation has to recognize which elements should be updated and which elements should be left unaltered during synchronization. In addition, a clear backward transformation usually does not exist from the target to the source domain. In this paper, we present an algorithm that facilitates incremental model synchronization in model transformation systems. The feasibility of the approach is also illustrated by a real world case study; we synchronize user interfaces of different mobile platforms.

A Model Driven Approach to Water Resource Analysis based on Formal Methods and Model Transformation

Business rules make an important and integral part of each information system (IS) by expressing business logic, constraints of concepts, and their interpretation and relationships. Therefore it is relevant to pay special attention to business rules in development of information systems. Rules related to domain structure and behaviour are presented in data, states, processes and other IS models. Taking into account that rules are expressed in several models, there is a risk that overall specification is inconsistent. Unambiguous models are crucial for the successful implementation of IS models transformation and finally code generation tasks. Therefore it is necessary to check consistency among related rules models. The problem of models inconsistency can be solved by using of formal or partially formal models with constraints. However formal models are often too complex to be used in practice. Semi-formal models are widely used, but constraints used in such a models often are suitable only for one model and relationships among models are not defined. Hence the author of paper suggests extending of IS approach based on semi-formal models and constraints, by adding the consistency rules for IS models. The proposed approach is illustrated by a case study.

Developing reliable yet flexible software is a hard problem. Although modeling methods enjoy a lot of advantages, the exclusive use of just one of them, in many cases, may not guarantee the development of reliable and flexible software. Formal modeling methods ensure reliability because they use a rigorous approach to software development. However, lack of knowledge and high cost practically force developers to use semi-formal methods instead. Semi-formal (visual) modeling methods, which are widely used in practical large-scale software development, are not good enough for reliable software development. This paper proposes a new approach to the development of reliable yet flexible software by transforming formal and semi-formal models into each other. In this way, the advantages of both methods are incorporated in to the software development process. The structured rules, proposed in this paper, transform formal and visual models into each other through the iterative and evolutionary process. The feasibility as well as the effectiveness of the proposed approach is demonstrated using the multi-lift system as a test case.

Model-Driven Development (MDD) aims at developing software more productively by using models as the main artifacts. Here, the models with high abstraction levels must be transformed into lower levels and finally executable models, i.e., source code. As a result, model transformation languages/tools play a main role on realizing the MDD goal. The Object-Management Group (OMG) presented the Query/View/Transformation (QVT) as a standard for the Meta-Object Facility (MOF)-based model transformation languages.However, implementing a model transformation language, which supports the full features of the QVT proposal requires a formal model of the underlying concepts. Having common terminology and a formal, precise, and consistent specification facilitates developing dependable transformation languages/tools.This paper aims to provide a formal specification of the main characteristics of a QVT-Relations (QVTr) model transformation language using the Z notation. The proposed formal model can be adapted for formalizing other domain and language concepts too. To show the applicability of the proposed formalism, a simplified version of the classic object-relational transformation is specified. Additionally, we show how the semantics clarifies some outstanding semantic issues in QVTr. The proposed formalism of this paper will pave the way to building support tools for model transformations in a unified manner in MDD.

Since most programmers are working on software that they did not start, their view of programming is that it is the process of converting one version of software to the next. In other words, software development is program transformation. This paper describes some of the implications of this point of view.

With advancements in display technology and increased user demands, automotive manufactures are targeting multiple displays, in various sizes and orientations. They are also adding features and interactions that span across multiple displays in an attempt to engage more users in the car. Today developers and designers use 'rapid prototyping' tools like UXPin and Framer, to quickly validate and test their ideas. But these tools do not support Multi-Screens and Multi-Displays prototyping environments. Also, other prototyping tools like EB Guide and Qt, which support such environments, require extensive software learning and development time that denies the purpose of 'rapid prototyping'. Hence, we propose a solution that would help any automotive designer and/or developers to quickly prototype and test their multi-media solutions for multi-screen vehicle system using any browser based UX tool.