SATToSE 2010

edit SideBar

Program

Monday

9h-9h30: Organization
9h30-12h: Short presentations of the participants

(Break at 10h30)

14h-18h (break at 16h) - Model/Code inconsistency management session

  • Inconsistency Resolution in Model-Driven Software Engineering using Automated Planning: A Feasibility Study by Jorge Pinna Puissant (UMons) Attach:PinnaPuissant.pdf
  • Diagnosis and correction of structural design inconsistencies in source code (with Logical Abduction) by Sergio Castro (UCL) Attach:DiagnosisCorrection.pdf
  • Models for Geographical Information Systems by André Miralles
  • Feature-Based composition of software architectures by Anthony Cleve
  • Software product line for enterprise architecture by Thibaut possompès

--
Tuesday

9h-12h (break at 10h30) Architecture evolution

  • Using Evolution Patterns to Introduce Styles into Software Architectures by Dalila Tamzalit
  • A multi-dimensional ADL for direct and reverse evolution of component-based software by Christelle Urtado
  • Collect ideas for the post-it session


Afternoon:

14h

  • Extraction of Component-Based Architecture From Object-Oriented Systems by Sylvain Chardigny
  • Vivisection of a non-executable, domain-specific language by Ralf Lämmel and Ekaterina Pek Attach:P3PVivisection.pdf

post-it session by Kim
choosing the topics of discussion
16h-18h: workshop coevolution chaired by Dalila Tamzalit and Christelle Urtado
Attach:coevolution

---
Wednesday

Morning (repositories, communities of developers, ecosystems)

  • Mining for Source Code Regularities using Association Rules by Angela Lozano (UcL) Attach:MiSoCoR.pdf
  • On the Analysis of Evolution FLOSS Ecosystems by Mathieu Goeminne (UMONS)
    Attach:MathieuGoeminne.pdf
  • Automated architecture component classification Using Concept Lattices by Sylvain Vauttier (EMA)
  • Hot Clones, Maintaining a Link Between Software Clones Across Repositories by Niko Schwarz

Afternoon

Short presentations of the demos

long session around the demos

Demos:

  • ERCA by Jean-Rémy Falleri
  • PopsYcle by Jean-Rémy Falleri
  • MTBE by Xavier Dolques
  • Use case Refactoring By Xavier Dolques

Walking in the garrigue of Clapiers

---
Thursday

Morning

  • ActiveContext, Implicit conversion of objects depending on the usage context by Erwann Wernli
  • Model Transformation by Example by Xavier Dolques

Break (10h30)

  • Working group

Afternoon

  • 14h Moose working group
  • Interaction graph
  • Free working groups

Talks

  • Extraction of Component-Based Architecture From Object-Oriented Systems by Sylvain Chardigny and Abdelhak-Djamel Seriai, University of Montpellier 2
    Software architecture modeling and representation became a main phase of the development process of complex systems. In fact, software architecture representation provides many advantages during all phases of software life cycle. Nevertheless, for many systems, like legacy or eroded ones, there is no available representation of their architectures. In order to benefit from this representation, we propose,in this presentation, an approach called ROMANTIC which focuses on extracting a component-based architecture of an existing object-oriented system. The main idea of this approach is to propose a quasi-automatic process of architecture recovery based on semantic and structural characteristics of software architecture concepts.
  • Using Evolution Patterns to Introduce Styles into Software Architectures by Dalila Tamzalit (University of Nantes) and Tom Mens (University of Mons - UMONS)
    Software architectures are critical in the successful development of software-intensive systems but also in their evolution. Due to the risk and complexity involved, software architects need formal and automated support to handle architectures they are in charge of. While the structural description of architectures has been widely addressed, their evolution is equally crucial, perhaps even more so, but significantly less well-understood and supported. We use the COSA architectural description language to propose architectural evolution patterns as a disciplined mechanism to restructure architectures to make them comply to a particular architectural style. We formalise architectural views, architectural styles and architectural restructurings using graph transformation theory. After a feasibility study of this formalisation using the AGG graph transformation tool, we implement our ideas by extending COSA Builder, a tool for describing software architectures, with explicit support for evolution patterns to introduce architectural styles.
    Key words: Software Architectures - Restructuring - Software engineering - Design - Evolution pattern - Architectural Style - Graph Transformation - ADL
  • On the Analysis of Evolution FLOSS Ecosystems by Mathieu Goeminne (UMONS)
    Interactions between user and developer communities on the one hand, and free/libre open-source sofware (FLOSS) evolution and quality on the other hand, have not been intensively studied. However, these communities significantly influence how the software evolves. We propose to study the effect that user and developer communities have on the evolution and the quality of FLOSS, thereby extending previous studies of FLOSS evolution with knowledge about the ecosystem that surrounds it. We outline our current research that consists in developing a tool framework allowing is to empirically study and analyse of the evolution of well-known FLOSS, to try to find a relation between their quality and development process.
    Keywords: software evolution, opensource software, ecosystem, software quality, software developer
  • Hot Clones, Maintaining a Link Between Software Clones Across Repositories by Niko Schwarz
  • ActiveContext, Implicit conversion of objects depending on the usage context by Erwann Wernli
    Structurally simple changes in the source code of a software project can have a large impact on the project as a whole. Refactoring tools mitigate this problem in many cases, but can't handle all. E.g., some source code may not be available, or cooperation between several module owners is required but can not be achieved. Thus, some changes are postponed ad eternam for various reasons.
    The aim of the project is to ease the introduction of such change by providing a way to temporarily mitigate incompatibilities while the whole project hasn't been updated yet. The key idea is to model the change as a first-class entity that can be authored by the developer, and at the same time serves to convert objects implicitly at run-time and prevent inconsistencies.
    We are still in an exploratory phase, but the abstraction seems interesting from several perspectives, including some creative uses that do not directly relate to software evolution.
  • Visualizing cycles with CycleTable by Simon Denier
    Identifying and understanding cycles in large systems is a challenging task. In this talk I will present CycleTable which displays both direct cycles (with 2 nodes) and indirect cycles (with 3 nodes and more). It shows how elementary cycles interconnect with each other to create strongly connected components. It helps the reengineer to devise simple strategies to remove cycles.
    I can't come this year
  • Inconsistency Resolution in Model-Driven Software Engineering using Automated Planning: A Feasibility Study by Jorge Pinna Puissant (UMons)
    In the context of Model-Driven Software Engineering, one of the main research challenges is to detect and resolve model inconsistencies in a generic and scaleable way. Various approaches have been explored in the past to address this problem. In this study, we outline our novel research that aims to use the technique of automated planning for the purpose of resolving model inconsistencies. Initial results appear promising, but a feasibility study is necessary to assess whether the approach scales up and works in practice.
    Keywords: Software Engineering, Inconsistency Management, Inconsistency Resolution, Automated Planning
  • Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction by Sergio Castro (UCL)
    Correcting design decay in source code is not a trivial task. Diagnosing and subsequently correcting inconsistencies between a systems’s code and its design rules (e.g. database queries are only allowed in the persistence layer) can be complex, time-consuming and error-prone. Providing support for this process is therefore highly desirable, but of a far greater complexity than suggesting basic corrective actions for recurrent implementation problems (e.g. the “remove unused import declaration” suggested by Eclipse). We present an abductive reasoning approach to inconsistency correction that consists of 1) a means for developers to document and verify a system’s design rules, 2) an abductive logic reasoner that hypothesizes possible causes of inconsistencies between the system’s code and the documented rules and 3) a library of corrective actions for each hypothesized cause. We validate our approach on IntensiVE —a tool suite that enables defining sets of source code artefacts intensionally (e.g. by means of a logic query) and verifying relationships between such sets.
    Keywords: Software Engineering, Inconsistency Management, Inconsistency Resolution, Logic Abduction
  • Vivisection of a non-executable, domain-specific language by Ralf Lämmel and Ekaterina Pek
    P3P is the policy language with which web sites declare the intended use of data that is collected about users of the site. We have systematically collected P3P-based privacy policies from web sites listed in the Google directory, and analysed the resulting corpus with regard to metrics and cloning of policies, adherence to constraints, coverage of the P3P language, and a number of additional properties of language usage. This effort helps understanding the de-facto usage of the non-executable, domain-specific language P3P. Some elements of our methodology may be similarly useful for other software languages.
  • Mining Source Code Regularities using Association Rules by Angela Lozano
    During the maintenance phase, developers must understand the constraints and contracts between the components of the system, to avoid architectural degradation. However, many of these constraints are implicit or their documentation outdated. To overcome this problem, we propose an approach to identify implicit regularities in the source code (e.g. naming conventions, design patterns, idioms, protocols of usage, etc.). This approach is based on Formal Concept Analysis and association rules. We extract from a static analysis of the source-code a set of facts that are classified using FCA. Based on this classification, we can detect related properties and exceptions using association rules. By relating properties, we are closer to make explicit the intension (as the specification of a set, not what the developer meant) of the design rules. The uses of regularity mining include documentation, guidance while modifying the code, and warnings when creating irregularities.

Demos

  • CycleTable by Simon Denier