We invite all authors to give to all participants (in the main conference room) a very brief introduction to the tool/poster (5 minutes, 5 slides).
After that, we will come to the hall and each author will have space to place his computer and any complementary material he may need (small poster, leaflets, etc..).
During the rest of the session, people will be walking around listening to the demos and making questions.
Of course demos and posters may continue after that, during coffee-breaks and at the beginning/ending of the day.
Visual Support for Understanding Product Lines
|
| Janet Feigenspan, Christian Kaestner, Mathias Frisch and Raimund Dachselt |
The C preprocessor is often used in practice to implement variability
in software product lines. Using ifdef statements brings problems like
obfuscated source code, yet they will still be used in practice at least
in the medium-term future. With CIDE, we demonstrate a tool to
improve understanding and maintaining code that contains ifdef
statements by visualizing them with colors and providing different
views on the code.
|
|
Patrools: Visualizing the Polymorphic Usage of Class Hierarchies
|
| Petru F. Mihancea |
Class hierarchies are key to flexible object-oriented
design, but can also burden program comprehension
activities when improperly designed or documented.
This tool demo presents an Eclipse plugin called
PATROOLS. It implements two software visualizations
that capture the polymorphic usage of a class
hierarchy by its clients, and can support
understanding and quality assessment tasks related
A to class hierarchies.
|
|
Renaming Parts of Identifiers Consistently within Code
|
| Patricia Jablonski and Daqing Hou |
Copying and pasting source code results in code duplication. A common form of
software reuse involves modifying the new duplicate to fit a current task. The
similar code fragments (code clones) may be edited inconsistently by the
programmer, for various reasons, leaving a bug in the software that may remain
undetected by both the programmer and the compiler. A previously published
tool, CReN, helps the programmer by
automatically renaming all instances of the same identifier consistently within a
clone when one is edited. In this tool demo, we introduce an extension of CReN,
an Eclipse plug-in named LexId, which renames the same parts of identifiers
consistently together within code clones.
|
|
A Tool for Detecting Complex Low-Level Dependencies
|
| Dirk Beyer and Ashgan Fararooy |
We present an Eclipse plug-in that identifies complex data-flow dependencies on
code-level. Low-level dependencies between program operations are modeled by
the use-def graph, which is generated from reaching definitions of variables. The
tool annotates program operations with their dependency degree, such that
‘difficult’ program operations are easy to locate. We hope that this tool helps
detecting and preventing code degeneration, which is often a challenge in today’s
software projects, due to the high refactoring and restructuring frequency.
|
|
CheckDep: A Tool for Tracking Software Dependencies
|
| Dirk Beyer and Ashgan Fararooy |
Many software developers use a syntactical ‘diff’ in order to perform a quick review
before committing changes to the repository. Others are notified of the change by e-mail
(containing diffs or change logs), and they review the received information to determine if
their work is affected. We lift this simple process from the code level to the more
abstract level of dependencies: a software developer can use CheckDep to inspect
introduced and removed dependencies before committing new versions, and other
developers receive summaries of the changed dependencies via e-mail. We find the tool
useful in our software-development activities and make the tool publicly available.
|
|
Featureous: A Tool for Feature-Centric Analysis of Java
|
| Andrzej Olszak and Bo Narregaard Jargensen |
Feature-centric comprehension of source code is necessary for
incorporating user-requested modifications during software evolution and
maintenance. However, such comprehension is difficult to achieve in case
of large object-oriented programs due to the size, complexity, and implicit
character of mappings between features and source code. To support
programmers in overcoming these difficulties, we present a feature-centric
analysis tool, Featureous. Our tool extends the NetBeans IDE with
mechanisms for efficient location of feature implementations in legacy source code, and an extensive analysis of the
discovered feature-code relations through a number of analytical views.
|
|
DynaRIA: a Tool for Ajax Web Application Comprehension
|
| D. Amalfitano, A. R. Fasolino, A. Polcaro and P. Tramontana |
Thanks to Rich Internet Applications (RIAs) with their enhanced interactivity,
responsiveness and dynamicity, the user experience in the Web 2.0 is
becoming more and more appealing and user-friendly. At the same time, the
dynamic nature of RIAs, and the heterogeneous technologies, frameworks,
communication models used for implementing them negatively affect their
analyzability and understandability, so that specific software techniques and
tools are needed for supporting their comprehension. This paper presents
DynaRIA, a tool for the comprehension of RIAs implemented in Ajax that is based on dynamic analysis and provides
functionalities for recording and analyzing user sessions from several perspectives, and producing various types of
abstractions and visualizations about the run-time behavior of the application.
|
|
The ConAn Tool to Identify Crosscutting Concerns in Object Oriented Systems
|
| Mario Luca Bernardi and Giuseppe Antonio Di Lucca |
This paper presents the main features of ConAn, a tool supporting an
approach to find scattered and tangled class members in OO systems
and to group them in concerns. The recovered information is useful
for refactoring/migration tasks, such as towards Aspect Oriented
Programming (AOP).
|
|
Unibench: A Tool for Automated and Collaborative Benchmarking
|
| Daniel Rolls, Carl Joslin and Sven-Bodo Scholz |
We have identified the need for a universal bench- marking tool that
enforces consistency as well as proper documentation. Enforcing these
aspects without restricting the tool’s applicability poses a major challenge.
This paper introduces a tool for coordinating the running of experiments
on remote machines. A simple web interface allows for source code to be
submitted. Experiments are run and results are publicly disseminated via a
web interface without user intervention. The system has already enabled
sharing of resources internationally and good scientific inquiry.
|
|
Recovering Traceability Links between Business Process and Software
System Components
|
| Lerina Aversano, Fiammetta Marulli, Maria Tortorella |
The relationships existing between a business process and the supporting software
system is a critical concern for the organizations, as it directly affects their performance. The
research described in this paper is concerned with the use of information retrieval techniques
to software maintenance and, in particular, to the problem of recovering traceability links
between the business process models and the components of the supporting software system.
|
|
Multi-Touch for Software Exploration
|
| Sandro Boccuzzo, Harald C. Gall |
The design of software systems is often so intricate that no individual can grasp the
whole picture. Multi-Touch screen technology combined with 3D software visualization offers a
way for software engineers to interact with a software system in an intuitive way. In this paper
we present first results on how such emerging technologies can be used to explore software
systems.
|
|
Towards Developing a Meta-Model for Comprehending Software
Adaptability
|
|
Mehdi Amoui, Sen Li, Edson A. Oliveira Junior, Ladan Tahvildari |
To modernize legacy software into adaptable software, a program understanding
procedure is needed to study software for identifying the mechanisms that support
adaptability. Though the procedure can benefit from modeling techniques, current software
meta-models do not fully support particular aspects of software adaptability. The goal of this
research is to develop a meta-model, which facilitate comprehending applications for
adaptability by annotating a set of pre-determined adaptability factors in software models. To
this end, we investigate application-level sensing and effecting mechanisms, identify the core
adaptability factors, and propose a meta-model for adaptability.
|
|
Sound as an Aid in Understanding Low-Level Program Architecture
|
|
Lewis Berman |
A tool and associated sound mapping have been developed for exploring and
understanding the static structure of Java programs’ packages, classes, interfaces, and
methods. The tool supplements visual use of the Eclipse IDE. A sound mapping provides
information regarding the identification of, characteristics of, and relationships among the
architectural entities.
|
|
SVS, BORS, SVSi: Three Strategies to relate Problem and Program Domains
|
|
Mario M. Berón, Maria João V. Pereira, Nuno Oliveira, Daniela da Cruz |
Program Comprehension is improved if: i) the Problem and Program Domains can be
related, and ii) this relation is shown in a suitable way to the programmer. Currently, there are
few strategies for reaching this important goal because it is not easy to: i) Identify meaningful
representations of the problem and program domains; and ii) Define a linking procedure. This
poster describes three strategies to overcome the difficulties mentioned above. These
strategies use static and dynamic information and traditional compilation techniques for
relating both domains.
|
|
Contract-based Slicing helps on safety Reuse
|
|
Sérgio Areias, Daniela da Cruz, Jorge Sousa Pinto |
In this poster we describe a work in progress aimed at using a variant of
specification-based slicing to improve the reuse of annotated software components, developed
under the so-called design-by-contract approach. We have named this variant as contractbased
because we use the annotations, more precisely the pre and post-conditions, to slice
programs intra and inter-procedures. The idea, expressed in the poster, is to take the precondition
of the reused annotated component as slicing criterion, and slice backward the
program where the component is called. In that way, we can isolate the statements that have
influence on the variables involved on the pre-condition and check if it is preserved by that
invocation, or not.
|
|