Tarja Systä

Predicting fault-proneness using OO metrics. An industrial case study

Software quality is an important external software attribute that is difficult to measure objectively. In this case study, we empirically validate a set of object-oriented metrics in terms of their usefulness in predicting fault-proneness, an important software quality indicator We use a set of ten software product metrics that relate to the following software attributes: the size of the software, coupling, cohesion, inheritance, and reuse. Eight hypotheses on the correlations of the metrics with fault-proneness are given. These hypotheses are empirically tested in a case study, in which the client side of a large network service management system is studied. The subject system is written in Java and it consists of 123 classes. The validation is carried out using two data analysis techniques: regression analysis and discriminant analysis.

Shimba—an environment for reverse engineering Java software systems

Shimba is a reverse engineering environment to support the understanding of Java software systems. Shimba integrates the Rigi and SCED tools to analyze and visualize the static and dynamic aspects of a subject system. The static software artifacts and their dependencies are extracted from Java byte code and viewed as directed graphs using the Rigi reverse engineering environment. The run‐time information is generated by running the target software under a customized SDK debugger. The generated information is viewed as sequence diagrams using the SCED tool. In SCED, statechart diagrams can be synthesized automatically from sequence diagrams, allowing the user to investigate the overall run‐time behavior of objects in the target system.

A study on the current state of the art in tool-supported UML-based static reverse engineering

Today, software-engineering research and industry alike recognize the need for practical tools to support reverse-engineering activities. Most of the well-known CASE tools support reverse engineering in some way. The Unified Modeling Language (UML) has emerged as the de facto standard for graphically representing the design of object-oriented software systems. However, there does not yet exist a standard scheme for representing the reverse-engineered models of these systems. The various CASE tools usually adopt proprietary extensions to UML and, as a result, it is difficult, or even impossible, to ensure that model semantics remains unambiguous when working with different tools at the same time. In this paper, we examine the capabilities of the two most successful industrial-strength CASE-tools in reverse engineering the static structure of software systems and compare them to the results produced by two academic prototypes. The comparisons are carried out both manually and automatically using a research prototype for manipulating and comparing UML models.

MAS — an interactive synthesizer to support behavioral modelling in UML

Minimally Adequate Synthesizer (MAS) is an interactive algorithm that synthesizes UML statechart diagrams from sequence diagrams. It follows Angluins framework of minimally adequate teacher to infer the desired statechart diagram by consulting the user. To minimize the consultations needed, MAS keeps track of the interaction with the user. Together with its general knowledge about sequence diagrams, this makes MAS to operate mostly without users help, but allowing her to guide the process in the critical points. In this paper we discuss the MAS algorithm and its practical implementation, integrated with a real-world UML modeling tool, the Nokia TED. Moreover, we discuss the interaction between the algorithm and the user as a medium of improving the algorithm and further decreasing the amount of user consultations needed. Furthermore, we show how MAS can be used to incrementally synthesize sequence diagrams into an edited or a manually constructed statechart diagram. Totally automatic synthesis algorithms may result in a state machine that contains undesired generalizations. Because MAS consults the user during the synthesis process, the user can be confident that such generalizations do not appear in the resulting statechart diagram.

Automated support for modeling OO software

We explore how automated tools might support the dynamic modeling phase of object oriented software development. We use the Object Modeling Technique as a guideline and notational basis, but in principle our approach is not tied to any particular OO methodology. We assume, however, that dynamic modeling exploits scenarios (as in OMT) describing examples of using the system being developed. Our techniques can easily be adopted for various scenario representations, such as sequence diagrams or collaboration diagrams in UML.

Understanding the behavior of Java programs

To fully understand the underlying architecture of an object oriented software system, both static and dynamic analyses are needed. Dynamic reverse engineering techniques are especially important for understanding the run-time behavior of objects in a distributed object systems and in systems that rely heavily on polymorphism. Shimba, a prototype reverse engineering environment, has been built to support understanding of an existing Java software system. The dynamic event trace information is generated automatically as a result of running the target system under a customized sdk debugger and viewed as scenario diagrams using the SCED tool (K. Koskimies et al., 1998). In SCED, state diagrams can be synthesized automatically from scenario diagrams. This facility is used to visualize the total behavior of a selected object or method, disconnected from the rest of the system. The paper demonstrates how Shimba aids understanding of the behavior of Java programs. A case study is made to validate the usefulness of the approach. The system under investigation is the FUJABA environment, consisting of almost 700 Java classes.To fully understand the underlying architecture of an object oriented software system, both static and dynamic analyses are needed. Dynamic reverse engineering techniques are especially important for understanding the run-time behavior of objects in a distributed object systems and in systems that rely heavily on polymorphism. Shimba, a prototype reverse engineering environment, has been built to support understanding of an existing Java software system. The dynamic event trace information is generated automatically as a result of running the target system under a customized sdk debugger and viewed as scenario diagrams using the SCED tool (K. Koskimies et al., 1998). In SCED, state diagrams can be synthesized automatically from scenario diagrams. This facility is used to visualize the total behavior of a selected object or method, disconnected from the rest of the system. The paper demonstrates how Shimba aids understanding of the behavior of Java programs. A case study is made to validate the usefulness of the approach. The system under investigation is the FUJABA environment, consisting of almost 700 Java classes.

Empirical studies in reverse engineering: state of the art and future trends

Starting with the aim of modernizing legacy systems, often written in old programming languages, reverse engineering has extended its applicability to virtually every kind of software system. Moreover, the methods originally designed to recover a diagrammatic, high-level view of the target system have been extended to address several other problems faced by programmers when they need to understand and modify existing software. The authors’ position is that the next stage of development for this discipline will necessarily be based on empirical evaluation of methods. In fact, this evaluation is required to gain knowledge about the actual effects of applying a given approach, as well as to convince the end users of the positive cost–benefit trade offs. The contribution of this paper to the state of the art is a roadmap for the future research in the field, which includes: clarifying the scope of investigation, defining a reference taxonomy, and adopting a common framework for the execution of the experiments.

On the relationships between static and dynamic models in reverse engineering Java software

An experimental environment for reverse engineering Java software is discussed. Static information is extracted from class files and viewed using Rigi reverse engineering environment. The dynamic information is generated by running the target software under a debugger. The debugged event trace information is viewed as scenario diagrams using a prototype tool called SCED. In SCED, state diagrams can be synthesized automatically from scenario diagrams. Dynamic information can also be attached to the static Rigi graph. Both static and dynamic views contain information about software artifacts and their relations. Such overlapping information forms a connection for information exchange between the views. SCED scenario diagrams are used for slicing the Rigi view and the Rigi view in turn, is used to guide the generation of SCED scenario diagrams and for raising their level of abstraction.An experimental environment for reverse engineering Java software is discussed. Static information is extracted from class files and viewed using Rigi reverse engineering environment. The dynamic information is generated by running the target software under a debugger. The debugged event trace information is viewed as scenario diagrams using a prototype tool called SCED. In SCED, state diagrams can be synthesized automatically from scenario diagrams. Dynamic information can also be attached to the static Rigi graph. Both static and dynamic views contain information about software artifacts and their relations. Such overlapping information forms a connection for information exchange between the views. SCED scenario diagrams are used for slicing the Rigi view and the Rigi view in turn, is used to guide the generation of SCED scenario diagrams and for raising their level of abstraction.

Towards a Model-Driven Process for Designing ReSTful Web Services

Representational State Transfer (ReST) architecture provides a set of constraints that drive design decisions towards architectural properties such as interoperability, evolvability and scalability. Designing a ReSTful service API involves finding resources and their relationships, selecting uniform operations for each resource, and defining data formats for them. It is often a non-trivial exercise to refine a functional specification, expressed in terms of arbitrary actions, to a resource-oriented, descriptive state information content. We argue that this process can be described as a series of model transformations, starting from service functionality and gradually refining the phase products until a ReSTful service API is reached. This paper outlines the process phases, transformations and intermediate models based on our experiences in developing ReSTful services and service APIs at Nokia Research Center. The process captures our understanding on how to systematically transform functional specifications into ReSTful Web service interfaces.

Dynamic analysis for reverse engineering and program understanding

The main focus of program understanding and reverse engineering research has been on modeling the structure of a program by examining its code. This has been the result of the nature of the systems investigated and the perceived goals of the reverse engineering activities. The types of systems under investigation have changed, however, and the maintenance objectives have evolved. Many legacy systems today are object-oriented and component-based. One of the most prominent maintenance objectives is system migration to distributed environments, most notably the World Wide Web, for interoperation with other systems. This new maintenance objective has a great impact on the types of models expected as products of reverse engineering. As the traditional static software analysis techniques keep their valuable role in program comprehension, additional techniques, especially those focusing on run-time analysis of the subject systems, become equally important. In this paper, we focus on the analysis of the systems dynamic behavior, as it pertains to understanding the systems processes and uses. We give an overview of currently used dynamic reverse engineering techniques and identify some challenges yet to be tackled.