Electronic Communications of the EASST (European Association of Software Science and Technology)
Not a member yet
887 research outputs found
Sort by
Lifting Parallel Graph Transformation Concepts to Model Transformation based on the Eclipse Modeling Framework
Get PDFModel transformation is one of the key concepts in model-driven software development. An increasingly popular technology to define modeling languages is provided by the Eclipse Modeling Framework (EMF). Several EMF model transformation approaches have been developed, focusing on different transformation aspects. This paper proposes parallel graph transformation introduced by Ehrig and Kreowski as a suitable framework for modeling EMF model transformations with multi-object structures. Multi-object structures at transformation rule level provide a convenient way to describe the transformation of structures with a variable number of recurring structures, dependent on concrete model instances. Parallel graph transformation means the simultaneous application of a set of transformation rules synchronized at the application of a kernel rule. We apply our extended EMF model transformation technique to model the simulation of statecharts with AND-states
Methodologies and Tools for OSS: Current State of the Practice
Get PDFOver the years, the Open Source Software (OSS) development has matured and strengthened, building on some established methodologies and tools. An understanding of the current state of the practice, however, is still lacking. This paper presents the results of a survey of the OSS developer community with a view to gain insight of peer review, testing and release management practices, along with the current tool sets used for testing, debugging and, build and release management. Such an insight is important to appreciate the obstacles to overcome to introduce certification and more rigour into the development process. It is hoped that the results of this survey will initiate a useful discussion and allow the community to identify further process improvement opportunities for producing better quality software
Modeling of Self-Organizing Systems: An Overview
Get PDFThis paper gives a systematic overview on modeling formalisms suitable for modeling self-organizing systems. We distinguish between micro-level modeling and macro-level modeling. On the micro level, the behavior of each entity and the interaction between different object must be described by the model. Macrolevel modeling abstracts from the individual entities and only looks at the behavior of the system variables of interest. The differentiations between discrete and continuous time and between discrete and continuous state space lead to different descriptions of the model
Open Source Verification under a Cloud
Get PDFAn experiment in providing volunteer cloud computing support for automated audits of open source code is described here, along with the supporting theory. Certification and the distributed and piecewise nature of the underlying verification computation are among the areas formalised in the theory part.
The eventual aim of this research is to provide a means for open source developers who seek formally backed certification for their project to run fully automated analyses on their own source code. In order to ensure that the results are not tampered with, the computation is anonymized and shared with an ad-hoc network of volunteer CPUs for incremental completion. Each individual computation is repeated many times at different sites, and sufficient accounting data is generated to allow each computation to be refuted
Position Statement: Models in Software and Systems Development
Get PDFThe development of software and systems is, by its very nature, highly depending on models. In the software and system’s design models play an important role, where they represent the constraining standards as well as the choices of ideas and perspectives applied in the systems modelling, implementation and technology. The general model of model-being, developed by the author, is briefly explained and is used to discuss model interconnections resulting from model compositions and metamodel applications. In this position statement it is claimed that the analysis of model interconnections, prerequisite to or underlying the software and systems design, should provide new insights into the designs architecture
A Deductive Verification Platform for Cryptographic Software
Get PDFIn this paper we describe a deductive verification platform for the CAO language. CAO is a domain-specific language for cryptography. We show that this language presents interesting challenges for formal verification, not only in the rich mathematical type system that it introduces, but also in the cryptography-oriented language constructions that it offers. We describe how we tackle these problems, and also demonstrate that, by relying on the Jessie plug-in included in the Frama-C framework, the development time of such a complex verification tool could be greatly reduced. We base our presentation on real-world examples of CAO code, extracted from the open-source code of the NaCl cryptographic library, and illustrate how various cryptography-relevant security properties can be verified
Safe Integration of Annotated Components in Open Source Projects
Get PDFThe decision of using existing software components versus building from scratch custom software is one of the most complex and important choices of the entire development/integration process. However, the reuse of software components raises a spectrum of issues, from requirements negotiation to product selection and integration. The correct tradeoff is reached after having analyzed advantages and issues correlated to the reuse. Despite the reuse failures in real cases, many efforts have been made to make this idea successful.
In this context of software reuse in open source projects, we address the problem of reusing annotated components proposing a rigorous approach to assure the quality of the application under construction. We introduce the concept of caller-based slicing as a way of certifying that the integration of a component annotated with a contract into a system will preserve the correct behavior of the former, avoiding malfunctioning after integration.
To complement the efforts done and the benefits of slicing techniques, there is also a need to find an efficient way to visualize the main program with the annotated components and the slices. To take full profit of visualization, it is crucial to combine the visualization of the control/data flow with the textual representation of source code. To attain this objective, we extend the notions of System Dependence Graph
and Slicing Criterion to cope with annotations
Navigating Across Non-Navigable Ecore References via OCL
Get PDFThe Eclipse Modeling Framework (EMF) and its meta-meta model Ecore support uni-directional and bi-directional references. It is quite common that references are defined uni-directionally only because of saving storage space or separating meta models, which is problematic when implementing Object Constraint Language (OCL) constraints that require navigation against the direction of uni-directional references. This is essential for certain approaches, e.g., incremental evaluation of OCL constraints on models shown by Altenhofen et al. that is used in SAP's Modeling Infrastructure (MOIN). In this paper, we present an approach that overcomes the aforementioned issue by providing navigation across non-navigable Ecore references via OCL. We further discuss different alternative solutions and briefly describe the realization that was outcome of a project in cooperation with the SAP AG
On A Graph Formalism for Ordered Edges
Get PDFThough graphs are flexible enough to model any kind of data structure in principle, for some structures this results in a rather large overhead. This is for instance true for lists, i.e., edges that are meant to point to an ordered collection of nodes. Such structures are frequently encountered, for instance as ordered associations in UML diagrams. Several options exist to model lists using standard graphs, but all of them need auxiliary structure, and even so their manipulation in graph transformation rules is not trivial.
In this paper we propose to enrich graphs with special ordered edges, which more naturally represent the intended structure, and define how lists can be manipulated. We show that the resulting category satisfies sufficient HLR properties to apply standard algebraic graph transformation. We believe that in a context where lists are common, the cost of a more complicated graph formalism is outweighed by the benefit of a smaller, more appropriate model and more straightforward manipulation
Specifying and Generating Editing Environments for Interactive Animated Visual Models
Get PDFThe behavior of a dynamic system is most easily understood if it is illustrated by a visual model that is animated over time. Graphs are a widely accepted approach for representing such dynamic models in an abstract way. System behavior and, therefore, model behavior corresponds to modifications of its representing graph over time. Graph transformations are an obvious choice for specifying these graph modifications and, hence, model behavior. Existing approaches use a graph to represent the static state of a model whereas modifications of this graph are described by graph transformations that happen instantaneously, but whose durations are stretched over time in order to allow for smooth animations. However, long-running and simultaneous animations of different parts of a model as well as interactions during animations are difficult to specify and realize that way. This paper describes a different approach. A graph does not necessarily represent the static aspect of a model, but rather represents the currently changing model. Graph transformations, when triggered at specific points of time, modify such graphs and thus start, change, or stop animations. Several concurrent animations may simultaneously take place in a model. Graph transformations can easily describe interactions within the model or between user and model, too. This approach has been integrated into the DiaMeta framework that now allows for specifying and generating editing environments for interactive animated visual models. The approach is demonstrated using the game Avalanche where many parallel and interacting movements take place