Rudolf K. Keller

Pattern-based reverse-engineering of design components

Many reverse-engineering tools have been developed to derive abstract representations from source code. Yet, most of these tools completely ignore recovery of the all-important rationale behind the design decisions that have lead to its physical shape. Design patterns capture the rationale behind proven design solutions and discuss the trade-offs among their alternatives. We argue that it is these patterns of thought that are at the root of many of the key elements of large-scale software systems, and that, in order to comprehend these systems, we need to recover and understand the patterns on which they were built. In this paper, we present our environment for the reverse engineering of design components based on the structural descriptions of design patterns. We give an overview of the environment, explain three case studies, and discuss how pattern-based reverse-engineering helped gain insight into the design rationale of some of the pieces of three large-scale C++ software systems.

Observations and lessons learned from automated testing

This report addresses some of our observations made in a dozen of projects in the area of software testing, and more specifically, in automated testing. It documents, analyzes and consolidates what we consider to be of interest to the community. The major findings can be summarized in a number of lessons learned, covering test strategy, testability, daily integration, and best practices. The report starts with a brief description of five sample projects. Then, we discuss our observations and experiences and illustrate them with the sample projects. The report concludes with a synopsis of these experiences and with suggestions for future test automation endeavors.

A change impact model for changeability assessment in object-oriented software systems

Growing maintenance costs have become a major concern for developers and users of software systems. Changeability is an important aspect of maintainability, especially in environments where software changes are frequently required. In this work, the assumption that high-level design has an influence on maintainability is carried over to changeability and investigated for quality characteristics. The approach taken to assess the changeability of an object-oriented (OO) system is to compute the impact of changes made to classes of the system. A change impact model is defined at the conceptual level and mapped on the C++ language. In order to assess the practicality of the model on large industrial software systems, an experiment involving the impact of one change is carried out on a telecommunications system. The results suggest that the software can easily absorb this kind of change and that well chosen conventional OO design metrics can be used as indicators of changeability.

Design components: towards software composition at the design level

Component-based software development has proven effective for systems implementation in well-understood application domains, but is still insufficient for the creation of reusable and changeable software architectures. Design patterns address these shortcomings by capturing the expertise that is necessary for reusable design solutions. However, there is so far no methodical approach to providing these conceptual design building blocks in a tangible and composable form. To address this limitation, we introduce the notion of design components, reified design patterns fit for software composition. In this paper, we define design components and explain their constituents and services. Furthermore, we detail the activities of design composition and illustrate them as a process within a four-dimensional design space. Moreover, we describe a prototype of a design composition environment. A case study helps illustrating our approach.

Software visualization tools: survey and analysis

Recently, many software visualization (SV) techniques and tools have become available. There is ample anecdotal evidence that appropriate visualization can significantly reduce the effort spent on system comprehension and maintenance, yet we are not aware of any quantitative investigation and survey of SV tools. This paper reports on a survey on SV tools which was conducted in spring 2000 with more than 100 participants. It addresses various functional, practical, cognitive as well as code analysis aspects that users may be looking for in SV tools. The participants of the survey rated the usefulness and importance of these aspects, and came up with aspects of their own. The participants were in general quite pleased with the SV tool they were using and mentioned various benefits. Nevertheless, a big gap between desired aspects and the features of current SV tools was identified. In addition, a list of improvements that should be done to current tools was assembled. Finally, the collected data tends to suggest that in general code analysis aspects were not highly supported by the tools.

Automated Prototyping of User Interfaces Based on UML Scenarios

User interface (UI) prototyping and scenario engineering have become popular techniques. Yet, the transition from scenario to formal specifications and the generation of UI code is still ill-defined and essentially a manual task, and the two techniques lack integration in the overall requirements engineering process. In this paper, we suggest an approach for requirements engineering that generates a user interface prototype from scenarios and yields a formal specification of the application. Scenarios are acquired in the form of collaboration diagrams as defined by the Unified Modeling Language (UML), and are enriched with user interface (UI) information. These diagrams are automatically transformed into UML Statechart specifications of the UI objects involved. From the set of obtained specifications, a UI prototype is generated that is embedded in a UI builder environment for further refinement. Based on end user feedback, the collaboration diagrams and the UI prototype may be iteratively refined, and the result of the overall process is a specification consisting of the Statechart diagrams of all the objects involved, together with the generated and refined prototype of the UI. The algorithms underlying this process have been implemented and exercised on a number of examples.

A Workflow-Oriented System Architecture for the Management of Container Transportation

In this paper, we introduce a workflow-oriented system architecture for the processing of client requests (CRs) for container transportation. In the context of multi-transfer container transportation, the processing of CRs can be achieved by specific sequences of interdependent activities. These sequences need to be just-in-time created. They also need to be adapted to deal with unexpected events that may occur. Workflow technology is used to model and to manage the processing of CRs. The creation and the adaptation of activity sequences require first, an optimized scheduling of a limited number of resources (by also respecting CRs constraints); and second, a number of special workflow concepts and functionality to correctly manage activity sequences. Optimization models are involved to take care of the resource management and of the activity scheduling. Enhancements of workflow concepts and functionality for workflow management systems are investigated to deal with an activity sequence creation and adaptation. Finally, the proposed architecture includes a rule processing part to reduce the time-consuming manual interaction with the system.

User interface prototyping based on UML scenarios and high-level Petri nets

In this paper, we suggest a requirement engineering process that generates a user interface prototype from scenarios and yields a formal specification of the system in form of a high-level Petri net. Scenarios are acquired in the form of sequence diagrams as defined by the Unified Modeling Language (UML), and are enriched with user interface information. These diagrams are transformed into Petri net specifications and merged to obtain a global Petri net specification capturing the behavior of the entire system. From the global specification, a user interface prototype is generated and embedded in a user interface builder environment for further refinement. Based on end user feedback, the input scenarios and the user interface prototype may be iteratively refined. The result of the overall process is a specification consisting of a global Petri net, together with the generated and refined prototype of the user interface.

Cohesion as changeability indicator in object-oriented systems

The assessment of the changeability of software systems is of major concern for buyers of large systems found in fast-moving domains such as telecommunications. One way of approaching this problem is to investigate the dependency between the changeability of the software and its design, with the goal of finding design properties that can be used as changeability indicators. In the realm of object oriented systems, experiments have been conducted showing that coupling between classes is such an indicator. However, class cohesion has not been quantitatively studied in respect to changeability. In the research presented, we set out to investigate whether cohesion is correlated with changeability. As cohesion metrics, LCC and LCOM were adopted, and for measuring changeability, a change impact model was used. The data collected on three test systems of industrial size indicate no such correlation. Manual investigation of classes supposed to be weakly cohesive showed that the metrics used do not capture all the facets of class cohesion. We conclude that cohesion metrics such as LCC and LCOM should not be used as changeability indicators.

Generating user interface prototypes from scenarios

Requirements capture by scenarios and user interface prototyping have become popular techniques. Yet, the transition from scenarios to formal specifications is still ill-defined, and prototyping remains weak in linking the application domain with the user interface. Most importantly, the prototyping and the scenario approaches lack integration in the overall requirements engineering process. We suggest a process that generates a user interface prototype from scenarios and yields a formal specification of the application. The approach is based on the Unified Modeling Language (UML), and the generated prototypes are embedded in a user interface builder environment for further refinement. The algorithms underlying the approach have been implemented and applied on a number of examples.