SATToSE is the Seminar Series on Advanced Techniques and Tools for Software Evolution. Its previous editions has happened in Waulsort (Belgium, 2008), Côte d'Opale (France, 2009), Montpellier (France, 2010), Koblenz (Germany, 2011, 2012) and Bern (Switzerland, 2013). Its seventh edition took place in L'Aquila (Italy) on 9-11 July 2014. Each edition of SATToSE witnesses presentations on software visualisation techniques, tools for coevolving various software artefacts, their consistency management, runtime adaptability and context-awareness, as well as empirical results about software evolution. The goal of SATToSE is to gather both undergraduate and graduate students to showcase their research, exchange ideas, improve their communication skills, attend and contribute technology showdown and hackathons. The highlights of the programme included five invited lectures (given by Marianne Huchard, Leon Moonen, Alfonso Pierantonio, Alexander Serebrenik, Tanja Vos), an interactive tutorial (by Anya Helene Bagge) and a hands-on hackathon (by Alexander Serebrenik). The detailed programme, as well as the pre-proceedings volume with moderated but not yet reviewed abstracts and drafts can be found on our website: http://sattose.org/2014.
We would like to express our gratitude to the following people (listed in lexicographic order) who provided the reviews for the submissions of this volume:
The call for post-proceedings contributions was communicated to all participants after the event — only some decided to pursue the finalisation of their contribution for the post-proceedings, others often solicited more co-authors, changed the title, included more results. As a result, we have received 12 submissions: one of them was a keynote add-on, one was a tutorial write-up, the rest were being extended versions of pre-proceedings abstracts.
Each submitted report has been reviewed by at least three different peers. All submissions with a conflict of interest with one of the editors (co-authored by them or their colleagues) were handled by the other editor. The emphasis was put on clear problem definitions and descriptions of advanced aspects of the techniques contemplated in the solution, as opposed to the finality of the obtained results. Thus, most submissions are intermediate reports on ongoing work or summaries of previously developed tools and papers. The authors received enough time after the review to take the feedback into account and finalise their submissions.
General Chair: Davide Di Ruscio (University of L’Aquila) Program Chair: Vadim Zaytsev (Universiteit van Amsterdam) Hackathon Chair: Alexander Serebrenik (TU Eindhoven) Steering Committee Chair Ralf Lämmel (Universität Koblenz) Local Committee:
Romina Eramo (University of L’Aquila)
Ludovico Iovino (University of L’Aquila) Steering Committee:
Michael W. Godfrey (University of Waterloo) Marianne Huchard (Université Montpellier 2) Tom Mens (University of Mons) Oscar Nierstrasz (University of Bern) Coen De Roever (Free University Brussels)
Vadim Zaytsev (Universiteit van Amsterdam) Post-proceedings Editors:
Davide Di Ruscio (University of L’Aquila)
Vadim Zaytsev (Universiteit van Amsterdam)
The methods of software engineering have improved significantly over half the century of its existence: we now have advanced languages that help to shape our thinking about both the problem and the solution; we have compilers and other grammarware that assists us in the most laborious tasks of translating programs written or drawn in software languages to machine code; we have various programming paradigms and schools of thought that allow us to represent our solutions in a concise yet efficient way. Programming environments have also grown, but the author of this contribution claims that the difference between an old Emacs and a modern Eclipse is less ground-breaking than the difference between, say, RPG and Swift. This report focuses on possible advanced techniques of profiling, testing, debugging and visualisation, prototyped in Pharo. “What Programmers Do with Inheritance in Java”, Replicated on Source
Inheritance is one of the key techniques of the object-oriented paradigm. As such, it has been thoroughly researched — this paper replicates one of such studies, published at ECOOP 2013. The original study found that the defined inheritance relationships are extensively used in the code, mostly for subtyping and reuse purposes, and that late-bound self-reference occurs frequently. This replication confirmed and complemented the results by running the same experiments on the source code as opposed to the byte code used in the original paper.
Software analyses often receives considerable profits from visualisation techniques, which help overcome the intangible nature of software by letting the user interact with concrete representations of various aspects of it. Some visualisations are also models which abstract from less important aspects and focus on the essentials. Yet, software corpora, quite often used in empirical software analysis — a software reverse engineering domain that requires useful and scalable visualisations — are not well-supported, as the authors of this report claim. This contribution presents Explora, an infrastructure that is specifically targeted at visualising software corpora (at this point, in Smalltalk and Java).
Code duplication is a well-known and well-researched code smell that can sometimes be linked to increased maintenance costs and creating difficulties in understanding a software system. One of the solutions addressing the issue involves detecting duplicated code, refactoring it into a separate function and replacing all the clones with appropriately parametrised calls to the new function. This report describes a confirmatory replication of a CodeSurfer-based tool for detecting such refactorable code clones based on the combination of program dependence graphs and backward program slicing.
Pharo (a Smalltalk IDE) has a recommendation facility called “code critics” which is used for signalling code controversial and suspicious implementation choices and for promoting good style language idioms. For instance, they report code smells and encourage correct use of object orientation. In this paper, code critics are re-evaluated based on a case study of the code of a big system with 51 packages (Moose). It was observed that some code critics tend to occur together and therefore should be grouped in issues of a higher level of abstraction; others occur only in presence of others up to the point of being overshadowed by them; some are even triggered by the same patterns and offer competing solutions. The approach is promising and can be applied broadly to any quality-driven program analysis.
Software testing is exercised at many levels, and if done at the Graphical User Interface (GUI) level, allows to create very realistic test cases due to close emulation of user behaviour. This report offers an extension of the TESTAR tool by the same authors and their collaborators. TESTAR implements a model-driven approach to test automation which generates test cases based on a model which is automatically derived from the GUI through the accessibility API. The extension revolves around action ranking and using machine learning techniques in order to execute sensible and sophisticated sequences of GUI actions instead of blindly making a random selection of clicks and keystrokes that are visible and unblocked in each state.
Development of complex and large model transformations can be optimised by composition of reusable smaller ones. Yet, composing them is a complex problem: typically smaller transformations are discovered and selected by developers from different and heterogeneous sources, and then chained by composition processes that are semi-automated at best. Without considering the semantic properties of a transformation, it is difficult for the user to make the right choice between two possible proposed chains. This report contains a proposal to classify such chains with respect to the coverage of the metamodels involved in the transformation.
The paper considers two main concepts in MDE: a metamodel as a model that all regular models in the ecosystem conform to; and a model transformation as a description of changes in models. Surfacing, formalising and maintaining relations between the artefacts of these two kinds is a big subdomain of modelware. This report presents an approach to understand structural characteristics of metamodels by looking at how model transformations depend on metamodels of their source and target models.
Architecture Description Languages are the focus of this paper: a brief overview of them is given, and one (Dedal) is explain in full detail. It formally defines the architecture of a software system on three levels: the abstract specification, the concrete configuration and the instantiated architecture assembly. Software evolution is expressed in Dedal in static invariants that bind descriptions together and in evolution rules that trigger changes at each level. The running example in the paper is a home automation software that is used to guide the reader through explanations of evolution in Dedal. The authors consider integrating the methods presented here, in an IDE platform to help developers embrace software evolution further.
Bidirectional transformations (BX) are a largely recognised quickly growing field of MDE. In BX, we usually deal with both ways of propagating information between two (or more) software artefacts — such changes are typically non-univocal in the sense that more than one correct solutions could be admitted and tolerated. However, most existing BX frameworks do not represent uncertainty explicitly. In this report, the authors insist that they should and show that it is quite possible in their framework, by re-explaining the non-deterministic nature of bidirectionality and presenting a case study with a family of cohesive models with uncertainty.
Software model consistency and synchronisation are often achieved by designing and implementing bidirectional transformations. This report demonstrates an early attempt to take a step towards a taxonomy of BX by illustrating a set of relevant properties of such mappings. The contribution is of an analytical nature: existing literature is analysed and characteristics of existing approaches are put into perspective.
Software modelling is considered to be a somewhat difficult or even obscure subdomain of software engineering, with some of its topics such as megamodelling leaning towards the obscure part. However, it can be explained in relatively simple terms and given to software evolution researchers, can prove to be a useful advanced technique of expressing relations between software artefacts. During SATToSE 2014, we have held an interactive tutorial on this topic, which this report tries to summarise and complement.