Demos and Posters Organization

Demos and posters will be held in the following two sessions in the joint coffee break area:

• Thursday 4th July, 15:45-17:45, and
• Friday 5th July, 10:15-12:45

Note that this is concurrent to breaks (the first half-hours, respectively), and some main conference tracks. Given the location, all conference attendees will have the opportunity to freely walk around and ask about posters, tools, and/or demos.

Demos and Posters

Averroes: Whole-Program Analysis without the Whole Program

This email address is being protected from spambots. You need JavaScript enabled to view it. , Ondrej Lhoták

University of Waterloo, Canada

Averroes is a tool that enables any existing whole-program call graph construction tool (e.g., Soot, Doop, WALA) to generate sound and precise application-only call graphs efficiently without analyzing the library. Averroes generates a placeholder library that over-approximates the possible behavior of the original library, based on the separate compilation assumption (SCA). The placeholder library is constructed quickly and is typically much smaller in size. Typical efficiency improvements of using Averroes are a factor of 4x to 12x in analysis time and 8x to 13x in memory usage. In addition, Averroes makes it easier to handle reflection soundly.

In this demonstration, we would like to show you how to use Averroes to generate the call graphs for some sample programs. We will explain how to configure the various options in Averroes. We will also show how to use the placeholder library to generate the call graph using Soot and Doop.

FPLA: A Modeling Framework for Describing Flexible Software Product Line Architecture

This email address is being protected from spambots. You need JavaScript enabled to view it. , Jessica Díaz, Juan Garbajosa, Agustin Yagüe

Technical University of Madrid (UPM) - Universidad Politécnica de Madrid
Systems & Software Technology Group (SYST), E.U. Informática, Madrid, Spain
This email address is being protected from spambots. You need JavaScript enabled to view it. , This email address is being protected from spambots. You need JavaScript enabled to view it. , This email address is being protected from spambots. You need JavaScript enabled to view it. , This email address is being protected from spambots. You need JavaScript enabled to view it.

Nowadays, Software Product Line (SPL) engineering has been widely-adopted in software development. SPL features are realized at the architectural level in product-line architecture (PLA) models. This demonstration presents the FPLA Modeling Framework. FPLA offers tool support for (i) modeling PLAs in a graphical way by providing mechanisms to specify the external and internal variability and the different artifacts of the PLA following a view model, (ii) documenting the design decision driving the PLA solution, (iii) tracing PLAs to features allowing change impact analysis, (iv) configuring a specific product architecture, and (v) translating PL specifications into code (automatically) by guarantying the traceability between PLA and code. FPLA has been used for modeling the PLAs from representative software exemplars to industrial projects, such as OPTIMETER, which has been involved in different developments of two ITEA projects (IMPONET and NEMO&CODED) focused on Smart Grids.

Watch the video!

Characterization of Adaptable Interpreted-DSML

Eric Cariou, Olivier Le Goaer, This email address is being protected from spambots. You need JavaScript enabled to view it. , Samson Pierre

Université de Pau

PauWare engine software is a Java API surrounded by an extra tool (the SCXML2PauWare code generator). PauWare engine allows the construction of end-user business applications using UML 2 on one side, Java ME, SE, EE or Android on the other side. PauWare engine enables the visual programming of complex component/service behaviors by specyfying UML 2 State Machine Diagrams. The execution semantics is that of UML 2, which slightly differs from that of Harel's original Statecharts. Developers may either construct behavioral models from UML 2 modeling tools (OMG XMI format), or from the W3C SCXML format, or they may choose to do so from scratch by directly using the PauWare engine API. PauWare engine makes models persistent at runtime and therefore makes them executable by preventing a break or a gap between the models and their incarnation in Java.

The GEMOC Initiative: On the Globalization of Modeling Languages

This email address is being protected from spambots. You need JavaScript enabled to view it. , Robert B. France, Jeff Gray, Jean-Marc Jézéquel

University Rennes 1 (France)
Colorado State University (USA)
University of Alabama (USA)

GEMOC is an open initiative that aims to develop breakthrough for software language engineering (SLE) approaches that support global software engineering through the coordinated use of multiple domain-specific languages. GEMOC researchers aim to provide effective SLE solutions to problems associated with the design and implementation of collaborative, interoperable and composable modeling languages.

The GEMOC initiative aims to provide a framework that facilitates collaborative work on the challenges of using of multiple domain-specific languages in software development projects. The framework consists of mechanisms for coordinating the work of members, and for disseminating research results and other related information on GEMOC activities. The framework also provides the required infrastructure for sharing artifacts produced by members, including publications, case studies, and tools.

QUIC Graphs: Relational Invariant Generation for Containers

This email address is being protected from spambots. You need JavaScript enabled to view it. , Bor-Yuh Evan Chang, Sriram Sankaranarayanan

University of Colorado Boulder, USA

Programs written in modern languages perform intricate manipulations of containers such as arrays, lists, dictionaries, and sets. We present an abstract interpretation-based tool for automatically inferring relations between the sets of values stored in these containers. Relations include inclusion relations over unions and intersections, as well as quantified relationships with scalar variables. We use an abstract domain constructor that builds a container domain out of a Quantified Union-Intersection Constraint (QUIC) graph parameterized by a variety of integer base domains. We demonstrate the application of QUIC graphs on a variety of programs extracted from the Python test suite.

GenMyModel : An Online UML Case Tool

This email address is being protected from spambots. You need JavaScript enabled to view it. , Alexis Muller, Vincent Aranega

Axellience, Lille, France

Costs and markets lead engineering teams to collaborate from different locations all over the world. Modelling tools are present in development processes to produce complex software and these tools have to be highly collaborative to permit teams to be productive. Axellience tries to resolve issues about distributed collaboration and modelling with GenMyModel.

Vasco: A Visual Churn Exploration Tool

Fleur Duseau, This email address is being protected from spambots. You need JavaScript enabled to view it. , Houari Sahraoui

DIRO, Université de Montreal, Canada

Bloat, and particularly object churn, is a common performance problem in modern framework-intensive applications that consists of an excessive use of temporary objects. Temporaries can impose a significant overhead during the execution due to increased initialization costs. Identifying and understanding sources of churn is a difficult and labor-intensive task, despite recent advances in automated analysis techniques. To address this problem, we designed Vasco, a tool that allows users to visually explore how programs use temporaries. Because churn often crosses method and even framework boundaries, Vasco makes it possible to track temporary objects from their creation to their use. Also, since churn often results from multiple methods within a given region collaborating to build complex temporary data structures, Vasco represents program regions explicitly using the Sunburst visual metaphor. Various churn-related metrics can be visualized using this metaphor, thereby allowing users to quickly identify regions that exhibit suspicious behavior.

Rational Software Architect Design Manager 4.x

This email address is being protected from spambots. You need JavaScript enabled to view it.

IBM, Canada

Modeling and design management is a key capability of an application lifecycle development of software and systems in an iterative and collaborative way using formalisms that are best suited for these tasks. It also enables management of designs in a shared repository, role based access to designs by stakeholders, parallel development of designs, change and configuration management of designs, linking designs to and previewing of other related lifecycle artifacts (e.g., requirements, tests, change requests), staying informed of design activities by team members, and understanding the impact of changes to/on designs down or up stream. Design management capability has been added to IBMís Collaborative Lifecycle Management (CLM) tool offering. The capability is available from a web client, as well as from the Rational Software Architect (RSA DM) modeling tool.

https://jazz.net/products/design-management/

BETTY - Behavioural Types for Reliable Large-Scale Software Systems

This email address is being protected from spambots. You need JavaScript enabled to view it. , Antonio Ravara

Dept. of Computing, University of Glasgow, UK
CITI and Dept. of Informatics, FCT, Univ Nova de Lisboa)

Modern society is increasingly dependent on large-scale software systems that are distributed, collaborative and communication-centred. Correctness and reliability of such systems depend on compatibility between components and services that are newly developed or may already exist. The consequences of failure are severe, including security breaches and unavailability of essential services. Current software development technology is not well suited to producing these systems, due to the lack of high-level structuring abstractions for complex communication behaviour.

The COST Action Behavioural Types for Reliable Large-Scale Software Systems uses behavioural type theory as the basis for new foundations, programming languages, and software development methods for communication-intensive distributed systems. Behavioural type theory encompasses concepts such as interfaces, communication protocols, contracts, and choreography. As a unifying structural principle it will transform the theory and practice of distributed software development.

An MDE Tool-Chain for Pattern-Based S&D Embedded System Engineering

This email address is being protected from spambots. You need JavaScript enabled to view it. , A. Ziani, J. Geisel and C. Jouvray

IRIT (University of Toulouse) and Trialog, France

In our work, we promote a new discipline for system engi- neering using a pattern as its first class citizen: Pattern-Based System Engineering (PBSE). Therefore, PBSE addresses two kind of processes: the one of pattern development and the one of system development with patterns. To interconnect these two processes we promote a structured model-based repository of patterns and their related models. This video tutorial3 presents the SEMCO MDE Tool Suite called TERESA and provides guidelines on how to use it to build and to store reusable artefacts (S&D patterns and property models) in the domain of assis- tance to the pattern-based secure and dependable embedded system en- gineering. Once the repository is available, it serves an underlying trust engineering process.

Watch the video!

Assurance Workbench – Business Process based Testing

This email address is being protected from spambots. You need JavaScript enabled to view it. , Pooja Yelure, Harshit Tiwari

Tata Consultancy Services, India

Design of an effective test suite is the most time consuming task in the software testing process. Business Process models document the operational processes of an enterprise, therefore can be used to derive tests that represent real-life usage scenarios for systems. Our toolset automates generation of end-to-end test cases from Business Process models, using rules annotated on the model to generate relevant test data. Business Rules can be captured separately and are used by the tool to validate the process model for correctness. Test selection using a variety of criteria including structural and weighted coverage helps compact the test suite. Standard coverage techniques such as boundary value analysis and pairwise can be applied to achieve specific coverage.

A Comparative Study of Manual and Automated Refactorings

This email address is being protected from spambots. You need JavaScript enabled to view it. , Nicholas Chen, Mohsen Vakilian, Ralph E. Johnson, Danny Dig

University of Illinois at Urbana-Champaign, USA

Understanding how developers evolve their code is important for researchers, tool builders, and ultimately, developers themselves, who would benefit from improved development practices and tools. Unfortunately, the traditional source of code evolution data are Version Control System (VCS) snapshots, which are imprecise and incomplete. To overcome these limitations, we developed CodingTracker, a tool that captures fine-grained and precise changes to the code. The captured code changes are so precise that CodingTracker's replayer enables us to reproduce the state of the evolving code at any point in time. Besides code changes, CodingTracker records many other developer actions, for example, invocations of automated refactorings, tests and application runs, interactions with VCS, etc. Our study shows that CodingTracker's data allows researchers to answer questions that could not be answered using VCS data alone. We augmented CodingTracker with an algorithm that infers refactorings from continuous code changes and showed that such inference is precise.

Feature-Oriented Programming With Object Algebras

Bruno C.d.S. Oliveira, This email address is being protected from spambots. You need JavaScript enabled to view it. , William R. Cook, Alex Loh

National University of Singapore
Centrum Wiskunde & Informatica (CWI)
University of Texas, Austin

Object algebras are a new programming technique that enables a simple solution to basic extensibility and modularity issues in programming languages. In this tool demo we will demonstrate the extension of basic object algebras with object algebra combinators to allow feature-oriented programming. The combinators support type safe, extensible, decoration and combination of object algebras. In the demo this is shown using a case study for context-free grammars. Specifically, we will show how this approach enables:

• Combining multiple operations: for instance, parsing and printing of grammars.
• Decoration of operations with aspects like tracing, memoization or fixpoint computation.
• Combining dependent operations: for instance, computing first sets of a grammar requires nullability analysis.

A light-weight annotation-based solution to design Domain Specific Graphical Modeling Languages

This email address is being protected from spambots. You need JavaScript enabled to view it. , Vincent Chapurlat, Marianne Huchard, Clémentine Nebut

LGI2P, Ecole des Mines d'Alès, Nimes
LIRMM, CNRS, Université Montpellier 2, France

DSML (Domain Specific Modeling Languages) are an alternative to general purpose modeling languages (e.g. UML or SysML) for describing models with concepts and relations specific to a domain. DSML design is often based on Ecore meta-models, which follow the class-relation paradigm and also require defining a concrete syntax which can be either graphical or textual. In this demo, we focus on graphical concrete syntax, and we introduce an approach and a tool (Diagraph) to assist the design of a graphical DSML. The main points are: non-intrusive annotations of the meta-model to identify nodes, edges, nesting structures and other graphical information; immediate validation of meta-models by immediate generation of an EMF-GMF instance editor supporting multi-diagramming. Diagraph plays the role of an extension to Ecore, and is based on a pattern recognition principle in order to infer most of the concrete syntax.

An Eclipse plug-in to link modeling and code proof, AGrUM: ACSL Generator from UML Model

This email address is being protected from spambots. You need JavaScript enabled to view it. , Thomas Polacsek, Stéphane Duprat

ONERA and Atos Intégration SAS, Toulouse, France

If Model Based Engineering (MBE) supports engineers from the specification to code generation, we want here to bridge the gap between models and static program analysis. Today, static analysis tools prove the source code correctness against a set of properties by using mathematical methods, without executing the program. If these techniques are quite efficient and are used in safety critical contexts (for instance: aeronautic, nuclear, etc.), they are quite difficult to understand and to use. AGrUM is a prototype Eclipse plug-in which purpose is to automatically generate proof properties for C programs from UML State Machine designs to which the programs must conform. These generated properties can then be automatically proved using static analysis tools.

Watch the video!

Requirements-level migration of legacy systems

This email address is being protected from spambots. You need JavaScript enabled to view it. , Wiktor Nowakowski, Norbert Jarzebowski, Kamil Rybinski, Slawomir Blatkiewicz

Warsaw University of Technology, Warsaw, Poland

Novel software development technologies introduce significant changes in system design, delivery and usage patterns. For many legacy applications it means that their further development becomes infeasible due to obsolescence of technologies they use. There thus arises the need for tools supporting automated migration of legacy systems into new paradigms. In this demonstration we will show such a tool suite. Its most important characteristic is that it operates at the level of stories (scenarios) traditionally produced during requirements speciffcation. The tools highly support extracting knowledge about the functioning of legacy applications and storing them in the form of precise requirement-level models. What is more, the tools enable automated transformation of these models into object-oriented code, compliant with new system structure. In the demonstration we present a recovery engine, a requirements-level editor and a transformation engine in the context of a case study example.

Watch the video!

Verification Condition Generation for Permission Logics with Abstract Predicates and Abstraction Functions

Stefan Heule, Ioannis T. Kassios, Peter Müller, This email address is being protected from spambots. You need JavaScript enabled to view it.

ETH Zürich, Switzerland

Chalice is a verification tool for concurrent programs that proves that programs are free from data races and deadlocks, do not cause run-time errors, and satisfy assertions provided by the programmer. To verify a program, Chalice generates a verification condition for each method of the program and passes it to an SMT solver. Hence, verification is modular and automatic. Chalice’s verification methodology centers around permissions; a memory location may be accessed by a thread only if that thread has permission to do so. We demonstrate Chalice with a focus on its support for data abstraction via abstract predicates and abstraction functions, as explained in our ECOOP paper.

Demonstration of a Tool for Consistent Three-way Merging of EMF Models

This email address is being protected from spambots. You need JavaScript enabled to view it. , Sabrina Uhrig, Bernhard Westfechtel

University of Bayreuth, Germany

Optimistic version control strategies allow for independent modifications of the same software model. As soon as these modifications happen concurrently, three-way merging comes into play. We have developed a formal approach and implemented a tool to meet the specific requirements of merging EMF model versions. Our approach is state-based and advances the state of the art by guaranteeing a consistent merge result. The implementation follows an incremental design: An intermediate structure, the merge model, is alternately modified by the merge tool and by the user until it remains conflict-free. The user interface shows a superimposition of the three versions and provides a wizard for the resolution of context-free and context-sensitive merge conflicts. We demonstrate our tool by means of a UML scenario where two sets concurrent modifications are merged with the help of user interactions.

Watch the video!

The Requirements Editor RED

This email address is being protected from spambots. You need JavaScript enabled to view it. , Maciek Kucharek

Technical University of Denmark (DTU), Denmark

The Requirements Editor (RED) is a tool to support teaching Requirements Engineering graduate courses. The need of tool support is quite obvious, but all the tools on the market covered only a small segment of these techniques, used a different (and often inconsistent) terminology, and were hard to customize. After several failed attempts to use pre-existing tools, we decided to build our own.

RED is based on Eclipse RCP which makes it relatively stable and comfortable to use. It covers a great variety of RE techniques, from stakeholder analysis and goal modeling via interaction design and classic textual requirements to UML models. Apart from bread-and-butter features like reporting, a help system, and an integrated glossary, RED also provides features specifically designed to improve the learning experience, and research-oriented features not found in conventional tools, such as model fragment folding or inspection support.

MetaEdit+: Creating Tool Support for Domain-Specific Modeling Languages

This email address is being protected from spambots. You need JavaScript enabled to view it.

MetaCase, Finland

With MetaEdit+ you can build Domain-Specific Modeling tools and generators - without having to write a single line of code. This demonstration shows how different domain-specific languages (DSLs) can be integrated with a common metamodel and how languages can be created iteratively while auto- matically updating existing models.

Watch the video!

Really Automatic Scalable Object-Oriented Reengineering

Marco Trudel, This email address is being protected from spambots. You need JavaScript enabled to view it. , Martin Nordio, Bertrand Meyer

ETH Zurich, Switzerland

AutoOO is a fully automatic migration tool that translates C programs into object-oriented Eiffel projects. The translation applies reengineering heuristics that extract design elements implicit in the C source and render them through Eiffel's object-oriented features. For example, C functions become Eiffel methods and are allocated to classes to achieve proper encapsulation. In this demo, we will demonstrate AutoOO in action on some open-source C programs. The main example will be "xeyes", the widget for the X Windows System showing two googly eyes following the cursor. After translating xeyes from C to object-oriented Eiffel, we will demonstrate how to modify the automatically translated code using Eiffel's standard IDE.

A Compositional Paradigm of Automating Refactorings

This email address is being protected from spambots. You need JavaScript enabled to view it. , Nicholas Chen, Roshanak Zilouchian Moghaddam, Stas Negara, Ralph E. Johnson

University of Illinois at Urbana-Champaign, USA

Making complex code changes is tedious and error-prone. Programming environments provide tool support for various code changes including refactorings. However, studies suggest that programmers greatly underuse automated refactorings and rarely use the ones that automate complex changes. We will demonstrate a refactoring tool that supports a new paradigm of automating refactorings called the compositional paradigm. In this paradigm, the tool designer decomposes a change into smaller ones. The tool automates these smaller changes, and programmers manually compose these changes to perform large changes. In contrast to the the wizard-based paradigm, in the compositional paradigm, programmers perform a complex change in multiple steps rather than a single step. The compositional paradigm provides more control and predictability and reduces the costs of configuring and learning the tool. Our analysis of existing refactoring tool usage data and controlled studies suggest that the compositional paradigm is natural to programmers and outperforms the wizard-based paradigm.