Skip to main content

IBM Leadership Seminars

Seminar Navigation

IBM Programming Languages and Development Environments Seminar 2008
on Innovations in Software Development
June 25, 2008
Organized by IBM Haifa Research Lab

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.

Leadership Seminars by year