SATToSE 2012

grammarware edited this page Oct 10, 2012 · 14 revisions

The 5th Seminar Series on Advanced Techniques & Tools for Software Evolution (SATToSE12) takes place in Koblenz, Germany on 19-23 August 2012 as an integral part of the Summer School on Software Technologies and Software Languages (SoTeSoLa 2012).

Below you'll find the preliminary program of the seminar. Please consult the for SoTeSoLa program about the technology showdown, hackathons, and working groups that are organized at SoTeSoLa.

Session 1: Monday, 20 August 2012: 13.30-15.30

Model-driven Engineering

Bidirectional Grammar Transformations slides
Vadim Zaytsev
Centrum Wiskunde & Informatica, The Netherlands

Grammars in the broad sense, such as software metamodels, interface definitions, data models and algebraic data types, are necessarily involved in the evolutionary process. Formulating and performing those transformation in a bidirectional way, allows to operate with considerable ease on complex evolution scenarios involving concurrent changes, reversible adjustments, traceability concerns and various change propagation schemes. In this presentation, an operator suite for bidirectional grammar transformations will be discussed and the details on its design will be explained.

Resolving Inconsistencies in Model-Driven Engineering using Automated Planning
Jorge Pinna Puissant
University of Mons, Belgium

One of the main challenges in model-driven software engineering is to deal with design model inconsistencies. Automated techniques to detect and resolve these inconsistencies are essential. We propose to use the artificial intelligence technique of automated planning for the purpose of resolving software model inconsistencies. We implemented a regression planner in Prolog and validated it on the resolution of different types of structural inconsistencies for generated models of varying sizes. We discuss the scalability results of the approach obtained through several stress-tests and discuss the limitations of our approach.

REST ASSURED
Tesfahun Tesfay
University of Twente, The Netherlands

My primary research interests are biased towards advanced language design and abstraction in any potential domain. I am very much interested in Model Driven and Aspect oriented technologies. I have designed and implemented an aspect DSL for car Production Company, an assignment that combines language design, abstraction, MDE and Aspect orientation. I also have an on going independent research project i.e. Model Driven Generic Aspect Language. Currently I am designing a language called REST ASSURED at Systematic Software Company. I have to come up with a new good Domain Specific Language (DSL) for modeling REST-API's. I have to create a nice syntax, and implement the compilation using Model Driven Engineering principle of step-wise refinement. The DSL and its generators should also be extensible, to easily add new target languages, database technologies, and data exchange formats. Programmers should be able to make choices at model level, a target language or target database for example. Programmers should also be able to specify hooks at model level. A code should be generated based on the specifications.

Tool Enablers

Software Visualization Services
Marie-Christin Ostendorp
University of Oldenburg, Germany

Software Visualization aims to visualize information about software systems, such as the structure and the behavior: Therefore an API will be developed in the context of my Bachelor-theses. The API will be used to generate a flexible and variable visualization of prior generated data of an analysis of the source code. The data will be available in form of a TGraph and the desired visualization can be specified in a metamodel. The approach aims to automatically generate a GReTL-Transformation out of the metamodel of the visualization and the given TGraph such that the data of the analysis can be transformed into an instance of the metamodel of the visualization. This instance will be rendered into a scalable vector graphic. So all in all it should be possible to achieve a flexible and variable visualization of arbitrary data.

Interprocedural Dependence Analysis for JavaScript
Jens Nicolay
Vrije Universiteit Brussel, Belgium

Tool support for software developers usually includes a catalog of on-demand source code refactorings, and on-the-fly source code pattern detection. Both refactoring and pattern detection rely on static analysis to determine non-trivial program properties without actually executing the program first. The research area of static analysis for JavaScript is very active, but also quite young. Therefore, advanced tool support for the development of JavaScript programs is still lacking. More specifically, tool support for concurrent/parallel programming in JavaScript currently does not exist, because there is no analysis that can reason over dependencies between expressions. The goal of my research is to design and implement such an interprocedural dependence analysis for JavaScript in order to support the development and execution of web applications that effectively make use of multicore systems on the client-side.

Agile Modeling
Jan Kurš
University of Bern, Switzerland

A key prerequisite for analyzing software models is to construct the model from the available program and data sources. Developing a parser for a new language is time-consuming and expensive. Even though techniques such as scavenging grammars from various sources can reduce this time, still several weeks may be needed to develop a usable parser for a typical mainstream language. The goal of my work is to develop techniques that would enable new program and data sources to be modeled within reasonably short time. The following characteristics of the problem lead us to believe this goal is reachable. Firstly, most programming languages are similar to other languages. Secondly, complete parsers are not needed for software modeling. Thirdly, a large base of existing code samples are available for analysis.

Session 2: Tuesday, 21 August 2012: 11.00-12.30

Analyzing and Monitoring the Evolution of Software Systems

Analyzing Software Ecosystems with SECONDA
Javier Pérez
University of Mons, Belgium

Software ecosystems are coherent collections of software projects that evolve together and are maintained by the same developer community. Tools for analysing and visualising the evolution of software ecosystems must not only take into account the software product, but the development community as well. SECONDA is a software ecosystem visualization and analysis dashboard that offers both individual and grouped analysis of the evolution of projects and developers belonging to the software ecosystem, at coarse-grained and fine-grained level. In its current incarnation, SECONDA is used to study the GNOME ecosystem and developer community.

Querying History of Software
Reinout Stevens
Vrije Universiteit Brussel, Belgium

Version control systems are an industry best practice. They allow developers to collaborate on the same project by sharing changes, developing experimental features, reverting changes, etc. Thus, a version control system contains the history and evolution of the stored software project. Logic program query tools have proven themselves successful in reasoning over a single version of a program. We propose a history query tool that combines the ideas of logic program query tools with the information residing in version control systems. We see two major stakeholders for such a tool. First, software developers can use it to gain insights in the software project. For example, a developer can find out which person is an expert on a certain piece of code (who introduced it, who made the most changes to it). Second, the mining software repository community already uses repositories to predict trends in the software evolution. They can benefit from a high-level query tool to extract the necessary information.

Architectural Monitoring
Andrea Caracciolo
University of Bern, Switzerland

Software architecture is about defining constraints that, if enforced, guarantee the fulfillment of a certain set of desired non-functional properties. Unfortunately these constraints are rarely formalized and alignment between actual and prescribed architecture is often hard to proof. Many tools and techniques have been developed in academia within the last 2 decades, but none of them seems to fit industrial needs. In this presentation we propose a research plan which aims to introduce a new continuous architectural alignment monitoring technique based on requirements collected during on-field studies.

Empirical Studies

Corpus Engineering in Empirical Research: Qualitas Study
Ekaterina Pek
University of Koblenz-Landau, Germany
Empirical research has increasing popularity in the contemporary Computer Science. One of its kinds is an analysis of large collections of software artifacts (e.g., programs/systems). This talk covers the basis of such empirical research, namely, preparation of a large corpus for analysis on the example of Qualitas, a curated collection of software systems.

On the State of the Practice in Software Quality in Industry: an Exploratory Survey
Tom Mens
University of Mons, Belgium

As part of a European ERDF project, we carried out a survey at Walloon software-producing companies to explore to which extent they use software development practices related to software quality. The survey is developed in a way that is easy to replicate, so that it can be repeated and extended with results from companies in other regions and countries. In this presentation, we report on the results of the survey, with respondents from about 60 companies in the Walloon region of Belgium. The survey targets the following high-level questions (subdivided in numerous subquestions):

  • What are the quality-related techniques most widely in the software development industry?
  • What are the main factors (usage of tools, standards, ...) determining the quality of the software product and software process? By analyzing the answers to these questions, we aim to get a better understanding in the level of training of software engineers working in industry, and we wish to get feedback on whether academic software engineering courses need to be adapted to better fit the actual industry needs.

Programs of past SATToSE editions