SATToSE 2009

Welcome to Sattose 2009!

Lightning introductory talks

• Visual Source Code Queries (Johan Brichau)
  Declarative code queries and software visualizations present complementary techniques to investigate the structure of a software system. Code queries permit to search for specific parts of interest while visualizations attract the attention to properties of parts of the system. We are working on tools and techniques to combine code queries with visualization in two ways: queries specify a visualization and visually-specified queries. pdf

• Inconsistency management in source code with abductive logic programming (Sergio Castro)
  Inconsistency management using abductive-logic programming techniques has been discussed as a promising mechanism in many areas of software engineering, such as requirements engineering, software design, and databases. This presentation discusses the application of this technique for the diagnosis and correction of inconsistencies in source code using the IntensiVE tool suite. pdf

• Process Extraction from Development Artifacts (Abram Hindle)
  As developers and stakeholders work together on a software project they create software artifacts such as changes, mailinglists, process logs, documentation, tests, translations, UI decorations, etc. These artifacts have various properties associated: modules, authors, files, and time. Luckily time is what binds all these artifacts together. We propose a way of exploiting timelines and time correlations of software artifacts, their entities and properties, to indicate what the underlying software development processes are observable. http1 http2

• Helvetia — Domain Specific Language Models (Lukas Renggli)
  We face increasing pressure to support the development and embedding of new languages into existing host environments. For language developers new language features should be easy to implement and to integrate into the existing infrastructure. Language users want to use these languages in a homogeneous development environment, to combine them, and to control the scope of their effect. http

• News from RMOD (Stéphane Ducasse)
  The RMod INRIA team recently got out of earth: it focuses on remodularisation of existing applications. keywords: Software maps, software metrics, modules, traits http

• Mining Design (Ir)regularities with Formal Concept Analysis (Kim Mens, with Andy Kellens)
  Tools like IntensiVE support documenting source-code regularities and verifying adherence to these regularities when the software evolves. But how can we automatically discover such regularities from the source code of a system that hasn't been documented with such regularities before? In this presentation we show our first steps in creating an automated tool that automatically discovers sets of source-code artefacts that exhibit at least two source-code regularities (for example classes that belong to a certain hierarchy and that follow a similar naming convention) together with a set of artefacts that respect one of the regularities but not the other. The latter artefacts are potential inconsistencies. This gives us a good idea of the coverage of the regularity as well as a good measure of the presence of significant regularities.

• Smart Annotations and Cognac (Andy Kellens, with Kris De Schutter)
  This presentation briefly showed to tools we have been working on recently. Smart Annotations is a simple Eclipse plugin that aids developers in annotating source code. By specifying logic rules, our tool warns developers when there are possible mismatches between the annotations and the source code. Cognac is an extension of the IntensiVE tool for verifying design rules in Cobol systems. Using a logic language and a number of static analyses, we were able to verify a range of design rules in an industrial case study.

• eDSM - Enriched Dependency Structural Matrix (Jannik Laval)
  It is a tool used to detect and to provide information to break cycles between packages of a system. It offers enriched cells showing contextual information information about the kinds of references made (inheritance, invocation, class references and class extension), the proportion of referencing entities and the proportion of referenced entities. It uses coloring information to an easier detection. This work has been implemented on top of the Moose reengineering environment and the Mondrian visualization framework (on VisualWorks and Pharo). pdf http1 http2

• Turning Moose into PhaMoose (Alexandre Bergel)
  Mondrian is a scriptable and interaction visualization engine. Currently, it is essentially used to visualize almost all aspect of software programs. My work is focused on making Mondrian for Pharo fast. Several optimization are implemented. Visualizing procedural C code has also gained of my attention.

• Managing Inconsistencies in Software Design Models using Artificial Intelligence Techniques (Jorge Pinna Puissant)
  The problem of dealing with inconsistencies in model-driven software evolution has many challenges. Among them, the time required for detecting and handling inconsistencies has to be sufficiently small so as not to disturb the designer in his work. In our research we propose to apply artificial intelligence techniques and heuristics to the domain of model inconsistency management, in order to reduce as much as possible the detection and handling time. More specifically, we try to use "Rule-based Systems" to detect the inconsistencies and "Automated Planning and Scheduling" techniques to handle the inconsistencies. pdf http

• Context-oriented Concurrent Programming (Jorge Ressia)
  In conventional software applications, synchronization code is typically interspersed with functional code, thereby freezing the synchronization policies in place while impacting understandability and maintainability of the code base. We propose a new approach to concurrency control which strictly separates the functional code from the synchronization policy to be used. Software entities use a dedicated abstraction to express their concurrency requirements, and are then dynamically adapted in a given concurrency context to use a suitable synchronization policy that meets those requirements. As a consequence, the code base remains uncluttered with synchronization code, and entities can adapt the policy to use to the current context or to the collaborations in play.

• Supporting Synchronous Software Development (Lile Hattori)
  In the context of global software development, where teams are geographically distributed, collaboration aspects, such as awareness, and synchronization are compromised by the lack of face-to-face communication. In this talk I will introduce a new approach to supporting collaboration in team-based software development. Our approach reduces the change propagation latency of current mainstream SCM systems and helps teams gain real-time awareness of the evolution of the software system. pdf

• Cloning as Industrial Practice (Mike Godfrey)
  In this talk, I will outline what our group has discovered about software code cloning in practice, including a taxonomy of how clones may be used for principled engineering purposes. pdf

• How Java Enterprise applications are not Java (Fabrizio Perin)
  In Java Enterprise Applications, information is not contained just in the Java source code but is spread in different places like XML configuration files or SQL scripts. For example, while the computation logic is specified in Java, the transaction management related to the computation is specified in an XML descriptor. Thus, a comprehensive analysis needs to take all these sources into account. We present a unified meta-model for JEAs and we exemplify the detection of transaction problems through two dedicated visualizations. pdf

• Mapmaking (with code and world) (Simon Denier)
  This talk briefly presents the main problem I have while porting Moose code from Visualworks to Pharo. I need a general picture of system organization into packages as well as package internals. Then I can relate elements to each other, dive into details, come back to the general picture. Thus I want maps. This talk discusses the general process of mapmaking in the real world, giving some basic principles, then present some simple ideas to make package maps. As a final thought, one should know that good maps come from good basemaps, i.e. good basic map layout. pdf

• Lively Fabrik and Lively Wiki (Jens Lincke)
  Lively Fabrik and Lively Wiki is an end-user web development and collaboration environment based on the Lively Kernel. It enables users to create rich and interactive Web pages and applications - without leaving the Web. pdf

• Tracks for restructuring models(Marianne Huchard)
  The talk presents main tracks we follow for restructuring models by mining meaningful abstractions: formal concept analysis, relational concept analysis, identifier analysis and similarity flooding. pdf

Scheduled Extended Presentations

Extended presentations are planned:

Tuesday

Wednesday

• Identifier Analysis (Marianne Huchard) TalkIdentifiers.pdf

Working groups

• Smart tools/IDE
• Source code mining / mining repositories group (mainly discussed a few techniques useful for mining)
• Visualisations
• Similarity flooding Paper Presentation