ESEC/FSE'97 | OO Reengineering Workshop | E-mail
Version 0.2 -- Latest Revision: August, 18th, 1997
This document provides an overview of all the material that has been submitted to the ESEC'97 Workshop on Object-Oriented Re-engineering. Each participant is supposed to read all the submitted material, so that the workshop itself can be devoted to discussion instead of presentations. Please do not immediately print out all the material: we will provide all workshop participants with some form of preceedings containing all of the submitted material.
The document starts with an alphabetically sorted list of the
submissions, providing the author(s), title and a (number of) links to
the corresponding submission. After that follows a more detailed
overview with abstracts of the submissions, contacts of the authors
etc.
The formats supported are:
This is the material as it was originally submitted. Currently, authors are allowed to revise their papers untill Wednseday, June 20th. After that, the submissions will be collected into a technical report for the University of Vienna and send to all workshop particpants.
Yih-Farn R. Chen
Emden R. Gansner
Eleftherios Koutsofios
AT&T Labs - Research
180 Park Ave.
Florham Park, New Jersey
{chen,erg,ek}@research.att.com
http://www.research.att.com/info/{chen,erg,ek}
Detecting unreachable code in C++ programs is frequently necessary in large software projects to help remove excess software baggage, select regression tests, and support software reuse studies. The language complexity introduced by class inheritance, friendships, and template instantiations in C++ requires a carefully-designed model to catch all necessary dependencies for correct reachability analysis while remaining practical for large systems. We describe such a C++ model with the granularity of top-level declarations and discuss our experiences in applying reachability analysis tools based on this model to industrial C++ code.
Oliver Ciupke
Forschungszentrum Informatik, Forschungsbereich Programmstrukturen
Reengineering requires modelling and understanding a system on many levels of abstraction. Grouping is a concept for building abstract views on object-oriented systems. Grouping is defined formally based on graph theory. Visualizing a system containing groups and manipulating a corresponding model by tools can be defined straight forward.
Udo Gleich -- gleich@dbag.ulm.DaimlerBenz.com
Thomas Kohler -- kohler@dbag.ulm.DaimlerBenz.com
Searching for methods and ways to transform object-oriented legacy systems into new framework-based applications is the main intention of the ESPRIT project FAMOOS. The partners involved expect a tremendous increase in software flexibility from this approach. This results in the understanding that effective reengineering of large-scale applications is not feasible without sufficient tool support. At this time there are already a few considerations about what tool support for reengineering should look like. This paper gives an overview of the work at Daimler-Benz regarding this. It starts with a short summary of the different tasks that could be related to the term reengineering. Subsequently, a generic proposal for a possible tool architecture is given. Finally the paper introduces a few tool-prototypes which are currently being developed at Daimler-Benz.
B. Henderson-Sellers
email: brian@csse.swin.edu.au
http://www.csse.swin.edu.au/brian/
The third generation OO methodology OPEN (Object-oriented Process, Environment and Notation) encompasses the full lifecycle of software development. It is structured in terms of a fully objectified lifecycle together with a set of Tasks and Techniques. Here, those Tasks and Techniques pertinent to re-engineering are discussed together with evaluation of their relevance to migration issues (from a traditional information system to an object-oriented architecture).
Eliezer Kantorowitz
Computer Science Dept.
Technion- Israel Institute of Technology
32000 Haifa, Israel
kantor@cs.technion.ac.il
http://www.cs.technion.ac.il/~kantor/
An object oriented reengineering of a legacy system led to the development of the extension complexity concept, which enables fast detection of problematic algorithms. A software system may be considered as an implementation of a number of different algorithms. An evaluation of the extension complexities of these algorithms can reveal algorithms, that are difficult to implement and to extend. Similar to space and time complexities the extension complexity of an algorithm may be evaluated in few minutes and give an indication of the suitability of the algorithm.
Vaclav Rajlich
Wayne State University
Department of Computer Science
Detroit, MI 48202
tel. 313-577-5423, fax 313-577-6868
rajlich@cs.wayne.edu
http://www.cs.wayne.edu/~vip/VaclavRajlich.html
This position statement presents a prototype tool "Ripples 2" which supports two processes of propagation of ripple effect in Object Oriented systems: change-and-fix, and top-down propagation (MSE). The paper also contains an example of the use of the tool.
Annya Romanczuk, Isabelle Borne
Ecole des Mines de Nantes
La chantrerie, 4 rue Alfred Kastler
44070 Nantes Cedex 03, France
Email: Annya.Romanczuk, Isabelle.Borne@emn.fr
The main goal of this project was to design a semi-automatic tool which, from a Merise analysis schema, produces an OMT analysis schema. This work was based on a real-world case provided by a company wishing to migrate to object-oriented techniques in order to improve its maintenance process and software quality. We extracted translation and transformation rules, in a systematic way, from the existing Merise analysis of the case study. A comparison of both methods led to define a set of automatic rules and a set of concepts for which there is no correspondence between the two analysis representations.
Benedikt Schulz
Forschungszentrum Informatik, Forschungsbereich Programmstrukturen
This paper describes a method for preserving behaviour during the reorganisation of object-oriented legacy systems written in standard object-oriented languages (e.g. C++, Smalltalk, Java, ADA). The method consists of three phases: In the first phase the legacy systems is transformed into an adaptive program. During the second phase the system is reorganised in a behaviour preserving way to fulfill new flexibility requirements. Finally the resulting adaptive program is retransformed to the original object-oriented language. The result of this process is a more flexible and adaptable system which is proven to be behaviourally equivalent to the source system.
Sander Tichelaar,
e-mail:
tichel@iam.unibe.ch
Stéphane Ducasse,
e-mail:
ducasse@iam.unibe.ch
Theo Dirk Meijler,
e-mail:
tdmeijler@research.baan.nl
In our workshop proposal we present a prototype approach to help the extraction of architectural information in the re-engineering process.
Commonly, the re-engineering life-cycle has been defined as a succession of the following tasks: analysis of requirements, model capture (understanding the system), problem detection, problem analysis, reorganisation and change propagation. We have evaluated the benefit of a prototyping approach with a focus on model capture. Although prototyping is a known approach to evaluate the application feasibility, costs, comparison and validation of choices, we focus in this paper on the aspects of prototyping that are helpful for re-engineering. We describe a pattern to use prototyping to extract architectural information, especially when there is a lack of good documentation and the original developers are difficult to access. A prototype can help to extract information from engineers, to detect problems that should have a solution in the existing software and to focus on different aspects like communication or user interfaces. And a running prototype demands awareness of behavioural aspects of the extracted structure.
Georg Trausmuth ( g.trausmuth@infosys.tuwien.ac.at)
Roland Knor ( r.knor@infosys.tuwien.ac.at)
Distributed Systems Group,
Technical University of Vienna
Argentinierstrasse 8/184-1, A-1040 Vienna, Austria
Complex data structures like lists and trees are difficult to implement in C in a way that programmers have no difficulties to maintain and reuse the source code. Thus, converting such data structures into instances of generic C++ components in order to increase the maintainabilty of the code is a reasonable task. Replacing data structures with instances of generic data structures is a non-trivial issue. Handling dependencies accordingly causes even more effort in the conversion. This paper points out the issues of replacing data structures with instances of generic components provided by libraries. We briefly desribe the transformation process, related issues and give an outlook on future activities in this area. This paper tries to stimulate a discussion of how generic source code components can influence reengineering and maintenance activities.
Arie van Deursen, CWI, Amsterdam,
arie@cwi.nl,
http://www.cwi.nl/~arie/
Tobias Kuipers, CWI, Amsterdam,
kuipers@cwi.nl,
http://www.cwi.nl/~kuipers/
We show that cluster analysis can support the extraction of an
object oriented re-design in that it can
(1) group instance variables into classes based on the common use
of global in the legacy source code;
(2) assign methods to classes based on the use of variables
in the procedures as occurring in the legacy code;
(3) visualize the common use of variables and procedures in the
legacy system.
We discuss how we employed cluster analysis in the extraction
of an object-oriented design from a 100 KLOC COBOL legacy system.
Y. Wang, G. King, I. Court, M. Ross and G. Staples
Research Centre for Systems Engineering
Southampton Institute, Southampton SO14 0YN, UK
Tel: +44 1703 319773, Fax: +44 1703 334441
Email: wang_s@solent.ac.uk or yingxu.wang@comlab.oxford.ac.uk
This paper provides a new approach for object-oriented reengineering. One of the difficulty in software testing and maintenance has been identified as caused by the convention that code and its tests are developed and described separately. This paper develops a method of built-in test (BIT) for OO reengineering. The advantage of this method is that the BITs in reengineered OO software (OOS) can be inherited and reused as that of code. Therefore building tests in the conventional software during OO reengineering can be a significant reengineering approach for the existing OO legacy systems.
Y. Wang, I. Court, M. Ross, G. Staples and G. King
Research Centre for Systems Engineering
Southampton Institute, Southampton SO14 0YN, UK
Tel: +44 1703 319773, Fax: +44 1703 334441
Email: wang_s@solent.ac.uk or yingxu.wang@comlab.oxford.ac.uk
A survey has been designed to seek the practical foundation of base process activities (BPAs) in the software industry and to support the research in modelling the software processes. Seven processes with 63 BPAs for object-oriented reengineering have been modelled and analyzed in the survey. This paper reports a subset of the survey on the BPAs for OO reengineering processes. Each BPA in the reengineering processes is benchmarked on the attributes of mean importance, ratio of practice and effectiveness. Based on the benchmark data, the OO reengineering processes in a software organization can be diagnosed and evaluated quantitatively, and process improvement opportunities can be identified and prioritized based on the importance and effectiveness of the BPAs within the processes.
Jens Janhnke and Albert Zuendorf
-- Currently no abstract is available