IBM Programming Languages and Development Environments
Seminar 2008
on Innovations in Software Development
June
25, 2008
Organized by IBM Haifa Research Lab
Abstracts
PDF version for printing (1,136 KB)
Extending Rational Team Concert (RTC) to Support the
Governance of Software Development Projects
Alex Kofman, Avi Yaeli, and Yael Dubinsky, IBM HRL
Governance is a process of establishing chains of
responsibility, authority, and communication (decision
rights) as well as establishing control mechanisms to enable
people to carry out their roles and responsibilities.
Governance in a specific organization is an iterative
process. It begins with the assignment of roles and decision
rights per goals that are set. The process continues with
the establishment of a set of mechanisms e.g., policies and
measurements to be enacted on a specific scope within the
organization. It then ends with the assessment that leads to
the refinement of the goals accordingly.
The governance of software development aims at implementing
the governance concept into software development projects.
Specifically, in order to facilitate governance of
development projects, appropriate tooling is crucial.
Governance tooling must provide non-obtrusive and powerful
support throughout the governance lifecycle, as well as
align with the principles of the software development
methods that are used. Development teams need the ability to
define and reflect upon who is responsible for what actions
within teams, and which policies and measurements will
ensure they are making effective decisions. Existing
development tools do not provide semantics and a consistent
interface to specify governance entities, enact them into
team environments and assess the effectiveness of their
adoption. In this work we present the concepts and
motivation that led us to the development of a governance
tool to support software development projects. Specifically,
this tool is developed as an extension of Rational Team
Concert (RTC), which is delivered as part of the Jazz
platform [9]. RTC includes the management of work items,
source control and build support. Among different
development methods, RTC is developed to support agile teams
[8] by providing a highly collaborative development
environment.
Automating Big Refactorings for Componentization and
the Move to SOA
Aharon Abadi, Ran Ettinger, and Yishai A. Feldman, IBM
HRL
Software componentization, the process of identifying and
extracting reusable components from existing programs, is
useful for modernizing legacy applications. In particular,
componentization is applicable for transforming such legacy
code to a Service-Oriented Architecture (SOA). Effective
transformation to SOA depends on the availability of
powerful tools to facilitate both the identification and the
extraction of reusable components.
Unfortunately, complete automation is impossible. The
identification and transformation process needs to be guided
by a human architect. Such architects need strong
refactoring tools to automate the tedious parts of this
process. Clearly, practitioners will not use any unreliable
or inflexible tool. A reliable tool must produce correct
results. Flexibility, in this context, includes not
rejecting legal refactorings, supporting the extraction of
non-contiguous code, and allowing a choice between valid
alternatives.
Based on our recent advances in method-extraction algorithms
and our earlier experience with automated large-scale
program transformations, we believe it is possible to
develop reliable and flexible tools to provide a high level
of automation for practitioners dealing with the process of
service identification and transformation to SOA.
The Aspect-Oriented Process Support Framework
Oren Mishali and Shmuel Katz, Technion
A framework is presented for introducing and enforcing
process support within development environments in the form
of rules. The rules are defined over an abstraction of the
underlying process. Based on their definition and on
reusable building-blocks taken from a repository, code
containing aspects and classes is automatically generated.
Integration of the code into a development environment
customizes it accordingly. The framework is lightweight and
flexible and thus facilitates iterative definition of the
support, which makes the rules more practical, and their
adoption easier.
The ERP Paradigm for ALM Environments - An Experience
Report
Shai Koenig, Comverse
This presentation describes the current status of DiME, a
proprietary ALM environment developed and deployed within a
global enterprise. The presentation will survey ALM
architectural paradigms, describe the DiME system as an
example of one of these paradigms and report on our
experience in developing and deploying the DiME ALM system.
Towards Trace Visualization and Exploration for
Reactive Systems
Shahar Maoz, Asaf Kleinbort, and David Harel, Weizmann
Institute
We present a dynamic technique for the visualization and
exploration of the execution traces of reactive systems. The
input is a designer's inter-object scenario-based behavioral
model, given as a set of UML2-compliant live sequence charts
(LSC), and a scenario-based execution trace of the system.
Our method allows one to visualize, and navigate through,
the activation and progress of the scenarios given in the
charts as they "come to life" during execution. Thus, we tie
the visualization of system execution traces with
model-driven design. Among other things, we support both
event-based and real-time-based tracing, and use detailed
on-demand mechanisms, multi-scaling grids, and gradient
coloring methods. We have implemented and tested our ideas
in a prototype tool called the Tracer. The work was
presented at VL/HCC 2007.
Whiteoak: Introducing Structural Typing into Java
Joseph Gil and Itay Maman, Technion
This paper presents WHITEOAK, a Java extension that
introduces structural type equivalence and subtyping into
the language. We argue that structural subtyping addresses
common software design problems, and promotes the
development of loosely coupled modules without compromising
type safety. Some key features of WHITEOAK include
structural recursive types, the ability to add method
implementations to structural types, and the handling of
constructors in a structural manner.
Reasoning on Finite Satisfiability in UML Class
Diagrams
Azzam Maraee, Victor Makarenkov, and Mira Balaban,
Ben-Gurion University
Models lie at the heart of the emerging Model-Driven
Engineering approach. In order to guarantee precise,
consistent and correct models, there is an urgent need for
efficient reasoning methods to verify model correctness.
This paper presents FiniteSat, an algorithm for the
recognition of finite satisfiability problems in UML class
diagrams with constrained generalization sets. We also
summarize our last results for other fragments of class
diagrams and recognition of finite satisfiability problems.
Keynote: On the Evolution of Tools and Languages
Axel Uhl, SAP AG
Model-driven software development could be regarded as a
natural evolution of classical compiler construction and
programming language design. We'll take a look at this
evolutionary process and understand what the contribution of
modeling means in this context. When understood right, great
benefits can result; but there are many caveats. We have to
understand them in order to avoid the potential problems and
make the contribution of modeling even more valuable in the
future.
YASSA: Yet Another Story of Agile Assessment
Gadi Lifshitz, Ayelet Kroskin, and Barak Yagour, Cisco,
and Yael Dubinsky, IBM HRL
Measuring and assessing an agile team is an important aspect
of the agile process, as it allows the team to gain insight
about itself in order to continuously adapt and improve; yet
there is no standard 'one-size-fits-all'
measurement/assessment tool. This paper emerged from the
transition to agile at Cisco over a period of almost two
years, covering several phases of the project. We focus on
an assessment tool based on a customized questionnaire that
was created and periodically used. We illustrate the use of
this questionnaire and analyze the results which followed.
Through the results we tell the story of the group,
emphasizing the lessons learned at important stages. The
assessment tool can be used as an additional mechanism to
other measuring means such as reflection sessions and
velocity burn down charts for continuous mprovement.
Model-Driven Development for Embedded Software Product
Lines
Julia Rubin, Tali Yatzkar-Haham, and Uri Avraham, IBM
HRL
Embedded software is becoming increasingly large and
complex. Many products today are developed for the
international market, thus, the software must be adapted to
different legal or cultural environments and to different
languages. In addition, manufacturers usually develop
software that supports a variety of physical devices, such
as different mobile phones models, or different printer
models, etc. As a result, manufacturers want to reuse more
of the software that they produce. To achieve this goal,
they adopt emerging software engineering techniques, like
software product line engineering, which relates to
engineering methods of creating a portfolio of similar
software systems from a shared set of software assets. These
techniques come in conjunction with well-known methods, such
as component-based development, which is a method of
describing software systems as compositions of configurable
components.
In this presentation, we describe our model-driven framework
for the development of software product lines. Our
development environment extends the IBM Rational toolset,
which is built on top of the Eclipse framework. It enables
rapid generation of individual products from a shared set of
software product line assets and supports transformations
into various product artifacts, including build scripts, so
that legacy software can be reused and composed at build
time. As a case study, we use a realistic example of a
Samsung Electronics digital printer product line, which
contains widely varied printers, from a minimalist inkjet
model to full-blown multifunctional color laser printers
with fax, scan, and copier facilities.
Traceability Technique for Specifications
Aharon Abadi, Mordechai Nisenson, and Yahalomit
Simionovici, IBM HRL
Traceability in software involves discovering links between
different artifacts and is useful for a myriad of tasks in
the software life cycle. We compare several different
Information Retrieval techniques for this task, across two
datasets involving real-world software with the accompanying
specifications and documentation. The techniques compared
include dimensionality reduction methods, probabilistic and
information theoretical approaches, and the standard vector
space model.