execution frequency

Understanding the run-time behavior of object-oriented legacy systems is a complex task due to factors such as late binding and polymorphism. Current approaches extract and use information from the complete execution trace of a system. The sheer size and complexity of such traces make their handling, storage, and analysis difficult. Current software systems which run almost non-stop do not permit such a full analysis. In this paper we present a lightweight approach based on the extraction of a condensed amount of information, e.g., measurements, that does not require a full trace. Using this condensed information, we propose a visualization approach which allows us to identify and understand certain aspects of the objects' lifetime such as their role played in the creation of other objects and the communication architecture they support.

Understanding the dynamic behavior of a workflow is crucial for being able to modify, maintain, and improve it. A particularly difficult aspect of some behavior is concurrency. Automated techniques which seek to mine workflow data logs to discover information about the workflows must be able to handle the concurrency that manifests itself in the workflow executions. This paper presents techniques to discover patterns of concurrent behavior from traces of workflow events. The techniques are based on a probabilistic analysis of the event traces. Using metrics for the number, frequency, and regularity of event occurrences, a determination is made of the likely concurrent behavior being manifested by the system. Discovering this behavior can help a workflow designer better understand and improve the work processes they are managing.

Most of today’s dynamic analysis approaches are based on method traces. However, in the case of objectorientation understanding program execution by analyzing method traces is complicated because the behavior of a program depends on the sharing and the transfer of object references (aliasing). We argue that trace-based dynamic analysis is at a too low level of abstraction for objectoriented systems. We propose a new approach that captures the life cycle of objects by explicitly taking into account object aliasing and how aliases propagate during the execution of the program. In this paper, we present in detail our new meta-model and discuss future tracks opened by it. 1

Programmers seek to answer questions as they investigate the functioning of a software system, such as “which execution path is being taken in this case?” Programmers attempt to answer these questions, which we call conceptual queries, using a variety of tools. Each type of tool typically highlights one kind of information about the system, such as static structural information or control-flow information. Unfortunately for the programmer, the tools seldom directly answer the programmer’s conceptual queries. Instead, the programmer must piece together results from different tools to determine an answer to the initial query. At best, this process is time consuming and at worst, this process can lead to data overload and disorientation. In this paper, we present a model that supports the integration of different sources of information about a program. This model enables the results of concrete queries in separate tools to be brought together to directly answer many of a programmer’s conceptual queries. In addition to presenting this model, we present a tool that implements the model, demonstrate the range of conceptual queries supported by this tool, and present the results of use of the conceptual queries in a small field study.

We present a method to identify stakeholders and their preferences about non-functional requirements (NFR) by using use case diagrams of existing systems. We focus on the changes about NFR because such changes help stakeholders to identify their preferences. Comparing different use case diagrams of the same domain helps us to find the changes that can occur. We utilize the Goal-Question-Metrics (GQM) method to identify variables that characterize NFR. Thus, we can systematically represent changes about NFR using the variables. The use cases that represent system interactions help us to bridge the gap between goals and metrics (variables). Thus, we can easily construct measurable NFR. In order to illustrate and evaluate our method, we applied our method to an application domain of the Mail User Agent (MUA) system.

We propose that collaborative software visualization can improve team software maintenance. We first review how visualization can support software maintenance from the perspectives of system understanding, process understanding and software evolution. From this, we conclude that visualization tools are rarely designed to provide explicit support for collaborative authoring and sharing of views. We then provide an overview of research from a Computer Supported Cooperative Work perspective, and propose that this research should be applied to software visualization. We explore the opportunities and challenges this research focus presents and conclude that more attention paid to the social aspects of software visualization should improve both individual and team processes in software maintenance. 1.

Basic problems encountered when trying to accurately and reasonably measure dynamic properties of a program are discussed. These include problems in determining and assessing specific, desirable metric qualities that may be perturbed by subtle and unexpected program behaviour, as well as technical limitations on data collection. Some interpreter or Java-specific problems are examined, and the general issue of how to present metrics is also discussed.

Semantics Graph (ASG) [BC00]. An ASG is graph is representing an abstract syntax tree (AST) with additional semantic information such as identifiers' scope, variables ' type, etc. The goal of the Datrix ASG model is completeness -- any kind of reverse engineering analysis should be doable on an ASG without having to return to the source code -- and language independence -- the model should be the same for all common concepts of C++, Java and other languages. 4.3 Why FAMIX? UML is currently embraced as "the" standard in object-oriented modeling languages [OMG99], the recent work of OMG on the Meta Object Facility (MOF) being the most noteworthy example. We welcome these standardization efforts, yet warn against the tendency to use UML as the panacea for all exchange standards or meta-models. In particular, we argue that UML is not sufficient to serve 4.3. WHY FAMIX? 37 as a meta-model for reengineering applications because (1) one is forced to rely on UML's built-in extension mechani...

Abstract. Understanding software-based systems is a task essential not only for engineering new applications but also for evolving existing ones. For complex systems, the graphical representation of various attributes and projections contributes to such understanding. Also, scenarios have proven to greatly accelerate software understanding by capturing abstract system behavior. For existing software, abstraction based on architectural concepts is required to address the overflow of information generated by static code and dynamic executions. This paper explores a tool-supported technique for the extraction of abstract Use Case Map (UCMs) scenarios from code, and reports on work in progress through an example. UCMs, as part of the upcoming User Requirements Notation, help visualizing behavior combined with structure at the architecture level, above the level of message exchanges and component behavior. The unusual application of UCMs proposed here promises interesting visualization and abstraction benefits over conventional approaches to the reverse engineering of scenarios while maintaining traceability to the code. 1