This page provides the listing and characterization of all 176 articles that were surveyed in our paper "A Systematic Survey of Program Comprehension through Dynamic Analysis", to appear IEEE Transactions on Software Engineering (available as technical report).

In addition to the manuscript (which only lists summarized articles), the table below also characterizes articles that were extended by their respective authors later on.

Several remarks:
# url first author title venue year cit. activity target method evaluation
1 urlWe propose a probabilistic model for representing dynamic information, as well as a web-service based distributed architecture for its collection and compression. Antoniol A Distributed Architecture for Dynamic Analyses on User-Profile Data CSMREuropean Conference on Software Maintenance & Reengineering 2004 3 trace oo, procedural compr./summ., heuristics case study, quantitative
2 urlThis paper presents an approach and a tool, named WANDA, that instruments web applications and combines static and dynamic information to recover the as-is architecture and, in general, the UML documentation of the application itself. Antoniol Understanding Web Applications through Dynamic Analysis IWPCInternational Workshop on Program Comprehension 2004 9 design/arch., views web filtering, static, vis. (std.) case study, quantitative
3 urlWe present an approach to feature identification and comparison for large object-oriented multi-threaded programs using both static and dynamic data. Antoniol Feature Identification: A Novel Approach and a Case Study ICSMInternational Conference on Software Maintenance 2005 26 features oo, threads filtering, mult. traces, static case study, comparison, quantitative
4 urlWe propose new statistical analyses of static and dynamic data to accurately identify features in large multithreaded object-oriented programs. Antoniol Feature Identification: An Epidemiological Metaphor TSEIEEE Transactions on Software Engineering 2006 8 features, survey oo, procedural, threads filtering, mult. traces, static case study, comparison, quantitative
5 urlWe describe four innovative visual representations of software that scale to production-sized systems and illustrate their usage in five software case studies involving: version history, differencing, static properties, performance profiles, and dynamic program slices. Ball Software Visualization in the Large IEEEIEEE Computer 1996 252 general, views procedural metrics, slicing, static, vis. (adv.) preliminary
6 urlIn this paper, we explore two new dynamic analyses based on program profiling. Ball The Concept of Dynamic Analysis FSEEuropean Software Engineering Conference & Symposium on the Foundations of Software Engineering 1999 114 general procedural fca, metrics, static preliminary
7 urlThis paper surveys research and commercial sequence diagram tools to determine the features they provide to support program understanding. Bennett A Survey and Evaluation of Tool Features for Understanding Reverse Engineered Sequence Diagrams JSMEJournal of Software Maintenance & Evolution 2008 0 general, survey, views oo compr./summ., filtering, patt. det., vis. (std.) case study, human subj.
8 urlIn this paper, we propose a prototype tool that supports users in locating and understanding feature implementation in large (>1 MLOC) C/C++ systems. A combination of static and dynamic analysis allows extracting of the function call graph during feature execution and interpreting it within the static architecture of the system. Bohnet Visual Exploration of Function Call Graphs for Feature Location in Complex Software Systems SOFTVISSymposium on Software Visualization 2006 7 features oo, procedural patt. det., slicing, static, vis. (adv.) preliminary
9 urlThis work focuses on architectural recovery for program understanding and reuse reengineering of legacy object-oriented systems. The proposed method is based on dynamic analysis of the system for the selected test cases that cover relevant use cases. Bojic A Use-Case Driven Method of Architecture Recovery for Program Understanding and Reuse Reengineering CSMREuropean Conference on Software Maintenance & Reengineering 2000 18 design/arch., views oo compr./summ., fca, vis. (std.) preliminary
10 urlThe objective of the work reported here is to define and assess a method to reverse engineer UML sequence diagrams from execution traces. Briand Towards the Reverse Engineering of UML Sequence Diagrams WCREWorking Conference on Reverse Engineering 2003 36 general, survey, views oo patt. det., vis. (std.) preliminary
11 urlThis article addresses the generation of traces to monitor the execution of distributed Java systems, and investigates the use of Aspect-Oriented Programming (AOP) as the instrumentation strategy to get the necessary information at runtime. Briand Tracing Distributed Systems Executions Using AspectJ ICSMInternational Conference on Software Maintenance 2005 4 general, views distributed, oo, threads patt. det., vis. (std.) case study, quantitative
12 urlThis paper proposes a methodology and instrumentation infrastructure toward the reverse engineering of UML (Unified Modeling Language) sequence diagrams from dynamic analysis. Briand Toward the Reverse Engineering of UML Sequence Diagrams for Distributed Java Software TSEIEEE Transactions on Software Engineering 2006 16 general, survey, views distributed, oo patt. det., vis. (std.) case study, quantitative
13 urlIn this paper, we discuss the addition of sampling support to AVID, and we present two case studies in which we experimented with animating sampled dynamic information to help with performance tuning tasks. Chan Scaling an Object-oriented System Execution Visualizer through Sampling IWPCInternational Workshop on Program Comprehension 2003 7 trace oo compr./summ., heuristics case study
14 urlThis paper presents a technique to discover patterns of concurrent behavior from traces of system events. Cook Event-Based Detection of Concurrency FSEEuropean Software Engineering Conference & Symposium on the Foundations of Software Engineering 1998 101 behavior procedural, threads heuristics, metrics, patt. det., vis. (std.) preliminary
15 urlIn this paper we present a technique that builds on our previous work in behavior discovery to find the points in the system that demonstrate mutually exclusive and synchronized behavior. Cook Discovering Thread Interactions in a Concurrent System WCREWorking Conference on Reverse Engineering 2002 6 behavior procedural, threads heuristics, metrics, patt. det., vis. (std.) preliminary
16 urlIn this paper we present a technique that builds on our previous work in behavior discovery to find the points in the system that demonstrate mutually exclusive and synchronized behavior. Cook Discovering thread interactions in a concurrent system JSSJournal of Systems & Software 2005 6 behavior procedural, threads heuristics, metrics, patt. det., vis. (std.) case study
17 urlIn this paper, we propose to use sequence diagrams to visualize information that is dynamically obtained from testsuites. Cornelissen Visualizing Testsuites to Aid in Software Understanding CSMREuropean Conference on Software Maintenance & Reengineering 2007 8 general, views oo filtering, heuristics, vis. (std.) preliminary
18 urlIn this paper, we propose the use of a novel trace visualization method based on a massive sequence and circular bundle view, constructed with scalability in mind. Cornelissen Understanding Execution Traces Using Massive Sequence and Circular Bundle Views ICPCInternational Conference on Program Comprehension 2007 6 features, trace, views oo compr./summ., filtering, static, vis. (adv.), vis. (std.) case study, industrial
19 urlIn this paper, we propose the use of two novel trace visualization techniques based on the massive sequence and circular bundle view, which both reflect a strong emphasis on scalability. Cornelissen Execution Trace Analysis through Massive Sequence and Circular Bundle Views JSSJournal of Systems & Software 2008 0 features, general, trace, views oo compr./summ., filtering, static, vis. (adv.), vis. (std.) case study, industrial
20 urlIn this paper, we propose an assessment methodology for the evaluation and comparison of trace reduction techniques. Cornelissen An Assessment Methodology for Trace Reduction Techniques ICSMInternational Conference on Software Maintenance 2008 0 survey, trace oo compr./summ., filtering, heuristics, metrics, mult. traces, patt. det. case study, quantitative
21 urlIn this paper, we present a platform-neutral visualization toolkit for TinyOS 2.0 to aid in program comprehension. Dalton A Toolkit for Visualizing the Runtime Behavior of TinyOS Applications ICPCInternational Conference on Program Comprehension 2008 0 general, views - filtering, static, vis. (std.) preliminary, quantitative
22 urlWe present a formalism to automate the most time-consuming aspect of this approach for locating code, namely: the partitioning of the input-sets into invoking and non-invoking sets. Deprez A formalism to automate mapping from program features to code IWPCInternational Workshop on Program Comprehension 2000 12 features procedural metrics, mult. traces, static preliminary
23 urlIn 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. Ducasse High-Level Polymetric Views of Condensed Run-time Information CSMREuropean Conference on Software Maintenance & Reengineering 2004 15 general, views oo filtering, metrics, vis. (adv.) case study
24 urlIn this paper we present a new technique called prune dependency analysis that can be combined with existing techniques to dramatically improve the accuracy of concern location. Eaddy CERBERUS: Tracing Requirements to Source Code Using Information Retrieval, Dynamic Analysis, and Program Analysis ICPCInternational Conference on Program Comprehension 2008 0 features oo filtering, heuristics, mult. traces, querying, slicing, static case study, comparison, quantitative
25 urlThis paper describes an approach to the feature location problem for distributed systems, that is, to the problem of locating which code components are important in providing a particular feature for an end user. Edwards An Approach to Feature Location in Distributed Systems JSSJournal of Systems & Software 2006 13 features distributed metrics, mult. traces case study, industrial
26 urlThis paper describes a new technique to derive the feature component map and additional dependencies utilizing dynamic information and concept analysis. Eisenbarth Derivation of Feature Component Maps by means of Concept Analysis CSMREuropean Conference on Software Maintenance & Reengineering 2001 11 features, views procedural fca, mult. traces, vis. (std.) case study
27 urlThis paper describes a new technique to derive the feature-component correspondence utilizing dynamic information and concept analysis. Eisenbarth Feature-Driven Program Understanding Using Concept Analysis of Execution Traces IWPCInternational Workshop on Program Comprehension 2001 29 features, views procedural fca, mult. traces, vis. (std.) case study
28 urlIn this paper, we present a technique building a mapping between the system's externally visible behavior and the relevant parts of the source code. Our technique combines dynamic and static analyses to rapidly focus on the system's parts urgently required for a goal-directed process of program understanding. Eisenbarth Aiding Program Comprehension by Static and Dynamic Feature Analysis ICSMInternational Conference on Software Maintenance 2001 77 features, views procedural fca, filtering, mult. traces, static, vis. (std.) case study
29 urlIn order to further validate the technique, we recently performed an industrial case study on a 1.2 million LOC production system. Eisenbarth Incremental Location of Combined Features for Large-Scale Programs ICSMInternational Conference on Software Maintenance 2002 14 features, views procedural fca, filtering, mult. traces, static, vis. (std.) case study, industrial
30 urlThis article describes a process and its supporting techniques to identify those parts of the source code which implement a specific set of related features. Eisenbarth Locating Features in Source Code TSEIEEE Transactions on Software Engineering 2003 168 features, views procedural fca, filtering, mult. traces, static, vis. (std.) case study, industrial
31 urlThis paper introduces an automated technique for feature location: helping developers map features to relevant source code. Eisenberg Dynamic Feature Traces: Finding Features in Unfamiliar Code ICSMInternational Conference on Software Maintenance 2005 23 features oo heuristics, metrics, querying, static case study, comparison, quantitative
32 urlLeNDI records traces of the legacy screen snapshots and user actions, while the user interacts with the legacy system. Then, it extracts a set of features for every snapshot and employs artificial intelligence methods to build a model of the legacy UI, called the statetransition graph. El-Ramly Modeling the System-User Dialog Using Interaction Traces WCREWorking Conference on Reverse Engineering 2001 24 behavior, features legacy compr./summ., vis. (std.) comparison, industrial, quantitative
33 urlWe have developed a method for modeling the application behavior from the user's perspective in the form of use case models, using recorded traces of system-user interaction. El-Ramly Mining System-User Interaction Traces for Use Case Models IWPCInternational Workshop on Program Comprehension 2002 24 behavior legacy compr./summ., patt. det., vis. (std.) industrial
34 urlWe have developed an algorithm, IPM, for interaction-pattern discovery. This algorithm discovers patterns that meet a user-specified criterion and may have insertion errors, caused by user mistakes while using the application or by the availability of alternative scenarios for the same user task. El-Ramly Recovering Software Requirements from System-user Interaction Traces SEKEInternational Conference on Software Engineering & Knowledge Engineering 2002 19 features legacy compr./summ., patt. det. industrial
35 urlTo address this problem of 'software requirements loss', we have developed an interaction-pattern mining method for the recovery of functional requirements as usage scenarios. Our method analyzes traces of the run-time system-user interaction to discover frequently recurring patterns; these patterns correspond to the functionality currently exercised by the system users, represented as usage scenarios. El-Ramly From Run-time Behavior to Usage Scenarios: An Interaction-Pattern Mining Approach SIGKDDInternational Conference on Knowledge Discovery and Data Mining 2002 15 features legacy compr./summ., metrics, patt. det. industrial
36 urlIn this paper, we propose a methodology to analyze and compare the execution traces of different versions of a software system to provide insights into its evolution. Fischer System Evolution Tracking through Execution Trace Analysis IWPCInternational Workshop on Program Comprehension 2005 6 trace, views procedural, threads metrics, mult. traces, vis. (adv.) case study
37 urlIn this paper, therefore, we present methodologies for characterizing the interfaces of web applications through a form of dynamic analysis, in which directed requests are sent to the application, and responses are analyzed to draw inferences about its interface. Fisher II Dynamic Characterization of Web Application Interfaces FASEInternational Conference on Fundamental Approaches to Software Engineering 2007 3 behavior web filtering, heuristics case study, quantitative
38 urlThis paper presents a tool, called Gadget, that helps software engineers extract the dynamic structure of object-oriented programs written in the Java programming language. Gargiulo Gadget: A Tool for Extracting the Dynamic Structure of Java Programs SEKEInternational Conference on Software Engineering & Knowledge Engineering 2001 9 general, views oo compr./summ., filtering, vis. (std.) preliminary
39 urlA novel approach to the runtime visualization and analysis of object-oriented programs is presented and illustrated through a prototype system called JIVE: J ava I nteractive Visualization Environment. Gestwicki Methodology and Architecture of JIVE SOFTVISSymposium on Software Visualization 2005 16 general, views oo, threads mult. traces, querying, vis. (std.) unknown/none
40 urlTo tackle these problems, we propose a compact feature-driven approach (i.e., summarized trace information) based on dynamic analysis to characterize features and computational units of an application. Greevy Correlating Features and Code Using A Compact Two-Sided Trace Analysis Approach CSMREuropean Conference on Software Maintenance & Reengineering 2005 41 features, views oo compr./summ., filtering, metrics, mult. traces, vis. (adv.) case study
41 urlTo tackle this issue we compact the traces into simple sets of source artifacts that participate in a feature's runtime behavior. We refer to these compacted traces as feature views. Greevy Analyzing software evolution through feature views JSMEJournal of Software Maintenance & Evolution 2006 5 features, views oo compr./summ., filtering, metrics, mult. traces, vis. (adv.) case study
42 urlTo tackle this problem, we propose an approach to software evolution analysis that exploits the relationships between features and software entities. Greevy Analyzing Feature Traces to Incorporate the Semantics of Change in Software Evolution Analysis ICSMInternational Conference on Software Maintenance 2005 17 features oo filtering, metrics, mult. traces, static case study
43 urlTo address this problem, we propose an interactive 3D visualization technique based on a combination of static and dynamic analysis which enables the software developer to step through visual representations of execution traces. Greevy Visualizing Feature Interaction in 3-D VISSOFTInternational Workshop on Visualizing Software for Understanding & Analysis 2005 5 features, views oo filtering, metrics, mult. traces, querying, static, vis. (adv.) case study
44 urlWe introduce a novel 3D visualization technique that supports animation of feature behavior and integrates zooming, panning, rotating and on-demand details. Greevy Visualizing Live Software Systems in 3D SOFTVISSymposium on Software Visualization 2006 9 features, views oo filtering, metrics, mult. traces, querying, static, vis. (adv.) case study
45 urlIn this paper we present a new instrumentation approach to reverse engineer a given software application. Our approach is based on aspect-oriented programming and provides support for dynamic feature analysis. Gschwind Improving Dynamic Data Analysis with Aspect-Oriented Programming CSMREuropean Conference on Software Maintenance & Reengineering 2003 17 general, views oo filtering, vis. (std.) case study
46 urlTraditional approaches for program comprehension use static program analysis or dynamic program analysis in the form of execution traces. Our approach, however, makes use of runtime-data such as parameter and object values. Gschwind Using Run-Time Data for Program Comprehension IWPCInternational Workshop on Program Comprehension 2003 10 general, views oo filtering, vis. (std.) case study
47 urlIn this paper, we present Caffeine, an assistant that helps the maintainer in checking her conjecture about the behavior of a Java program. Guéhéneuc No Java without Caffeine: A Tool for Dynamic Analysis of Java Programs ASEInternational Conference on Automated Software Engineering 2002 24 general oo filtering, online, querying case study, quantitative
48 urlWe propose a reverse-engineering tool suite, Ptidej, to build precise class diagrams from Java programs, with respect to their implementation and behaviour. Guéhéneuc A Reverse Engineering Tool for Precise Class Diagrams CASCONConference of the Centre for Advanced Studies on Collaborative Research 2004 14 general, views oo compr./summ., filtering, online, querying, static, vis. (std.) case study
49 urlThis led us to create a comprehension-driven compression framework that compresses the traces to make them more understandable. In this paper, we present and explain its components. Hamou-Lhadj Compression Techniques to Simplify the Analysis of Large Execution Traces IWPCInternational Workshop on Program Comprehension 2002 25 trace procedural compr./summ., patt. det. case study, quantitative
50 urlVisualization tools need to implement efficient filtering techniques to remove unnecessary data and present only information that adds value to the comprehension process. This paper addresses this issue by presenting different filtering techniques. Hamou-Lhadj Techniques for Reducing the Complexity of Object-Oriented Execution Traces VISSOFTInternational Workshop on Visualizing Software for Understanding & Analysis 2003 8 trace oo compr./summ., filtering, patt. det. case study, quantitative
51 urlIn this paper, we propose a graph-based format, called Compact Trace Format (CTF), for exchanging traces of object interactions. Hamou-Lhadj A Metamodel for Dynamic Information Generated from Object-Oriented Systems ENTCSElectronic Notes in Theoretical Computer Science 2004 28 trace oo compr./summ., patt. det. preliminary
52 urlIn this paper, we propose that if various aspects that contribute to a trace.s complexity could be measured and if this information could be used by tools, then trace analysis could be facilitated. Hamou-Lhadj Measuring Various Properties of Execution Traces to Help Build Better Trace Analysis Tools ICECCSInternational Conference on Engineering of Complex Computer Systems 2005 3 trace oo compr./summ., metrics, patt. det. case study, quantitative
53 urlIn this paper, we argue that [existing trace complexity metrics] provide limited indication of the effort required to understand the content of a trace. We address this issue by introducing new trace complexity metrics based on the concept of entropy. Hamou-Lhadj Measuring the Complexity of Traces Using Shannon Entropy ITNGInternational Conference on Information Technology: New Generations 2008 0 trace oo metrics, patt. det. case study, quantitative
54 urlThis paper focuses on these issues and underlies future research directions to advance the area of dynamic analysis of large software systems. Hamou-Lhadj Challenges and Requirements for an Effective Trace Exploration Tool IWPCInternational Workshop on Program Comprehension 2004 6 trace, views oo compr./summ., filtering, patt. det., vis. (std.) unknown/none
55 urlThis paper presents the state of the art in the area of trace analysis. Hamou-Lhadj A Survey of Trace Exploration Tools and Techniques CASCONConference of the Centre for Advanced Studies on Collaborative Research 2004 34 survey, trace oo - unknown/none
56 urlIn this paper, we first define the concept of utilities; then we present an algorithm based on fan-in analysis that can be used for the detection of utilities. Hamou-Lhadj Recovering Behavioral Design Models from Execution Traces CSMREuropean Conference on Software Maintenance & Reengineering 2005 28 behavior, trace, views oo compr./summ., filtering, metrics, static, vis. (std.) preliminary
57 urlIn this paper, we present a semi-automatic approach for summarizing the content of large execution traces. Hamou-Lhadj Summarizing the Content of Large Traces to Facilitate the Understanding of the Behaviour of a Software System ICPCInternational Conference on Program Comprehension 2006 7 trace oo compr./summ., filtering, metrics, static, vis. (std.) case study, human subj., quantitative
58 urlWe present a set of requirements for an aid to assist in the human understanding and exploration of the behavior of such applications through the incremental refinement of rules for determining causality relationships between messages sent among components. Hendrickson An Approach for Tracing and Understanding Asynchronous Architectures ASEInternational Conference on Automated Software Engineering 2003 2 behavior, views distributed, procedural, threads heuristics, querying, vis. (std.) preliminary
59 urlThis paper presents a novel, complete approach that aids in the understanding, debugging, and visualization of the behaviors of event-based applications. Hendrickson An (Architecture-centric) Approach for Tracing, Organizing, and Understanding Events in Event-based Software Architectures IWPCInternational Workshop on Program Comprehension 2005 1 behavior, views distributed, procedural, threads heuristics, querying, vis. (std.) case study
60 urlWe detect interaction patterns in legacy code combining static and dynamic analyses. Heuzeroth Combining Static and Dynamic Analyses to Detect Interaction Patterns IDPTInternational Conference on Integrated Design and Process Technology 2002 38 behavior, design/arch. legacy, oo filtering, patt. det., static preliminary
61 urlWe detect design patterns in legacy code combining static and dynamic analyses. Heuzeroth Automatic Design Pattern Detection IWPCInternational Workshop on Program Comprehension 2003 65 behavior, design/arch. legacy, oo filtering, patt. det., static case study, quantitative
62 urlIn this paper, we present a practical approach to enlarge the recoverable scope and improve precision ratio of pattern recovery. Huang A practical pattern recovery approach based on both structural and behavioral analysis JSSJournal of Systems & Software 2005 3 behavior, design/arch. oo filtering, mult. traces, patt. det., querying, static case study, quantitative
63 urlThis work identifies the components and interactions that are active during a tracing experiment, hence the name "effective architecture" and also derives layered performance models. Israr Interaction tree algorithms to extract effective architecture and layered performance models from traces JSSJournal of Systems & Software 2007 1 design/arch., trace oo compr./summ., mult. traces, patt. det. case study
64 urlThe Information Mural is a two-dimensional, reduced representation of an entire information space that fits entirely within a display window or screen. Jerding The Information Mural: A Technique for Displaying and Navigating Large Information Spaces TVCGIEEE Transactions on Visualization and Computer Graphics 1998 127 trace, views oo filtering, vis. (adv.) preliminary
65 urlThis work seeks to identify, visualize, and analyze interactions in object-oriented program executions as a means for examining and understanding dynamic behavior. Jerding Visualizing Interactions in Program Executions ICSEInternational Conference on Software Engineering 1997 108 trace, views oo filtering, patt. det., static, vis. (adv.), vis. (std.) preliminary
66 urlThis paper describes an analysis technique for gaining such understanding and a visualization tool, called ISVis, that supports it. Jerding Using Visualization for Architectural Localization and Extraction WCREWorking Conference on Reverse Engineering 1997 98 trace, views procedural filtering, patt. det., static, vis. (adv.), vis. (std.) case study
67 urlIn this paper we propose an approach for mining such usage scenarios from run-time communication between sample applications and the API. Jiang Constructing Usage Scenarios for API Redocumentation ICPCInternational Conference on Program Comprehension 2007 0 behavior procedural filtering, vis. (std.) unknown/none
68 urlThis paper reports on a study by Motorola Inc. and the Software Engineering Research Center to see if industrial tools currently in use at the company could be adapted for feature understanding. Jiang Software Feature Understanding in an Industrial Setting ICSMInternational Conference on Software Maintenance 2006 7 features procedural - industrial
69 urlIn this paper, we propose a log abstraction technique which recognizes the internal structure of each log line. Jiang An Automated Approach for Abstracting Execution Logs to Execution Events JSMEJournal of Software Maintenance & Evolution 2008 0 trace oo compr./summ., heuristics, metrics case study, comparison, industrial, quantitative
70 urlWe propose a new model for understanding runtime behavior that presents several advantages over the more traditional models Kelsen A Simple Static Model for Understanding the Dynamic Behavior of Programs IWPCInternational Workshop on Program Comprehension 2004 2 general, views oo static, vis. (std.) unknown/none
71 urlIn this paper we address the need to understand the behavior of objects in order to facilitate code sharing and reusability. Kleyn GraphTrace - Understanding Object-Oriented Systems Using Concurrently Animated Views OOPSLAConference on Object-Oriented Programming Systems, Languages, & Applications 1988 71 general, views oo static, vis. (std.) case study
72 urlIn this paper however, we focus on the extraction of behavioural information from program code. Kollmann Capturing Dynamic Program Behaviour with UML Collaboration Diagrams CSMREuropean Conference on Software Maintenance & Reengineering 2001 29 general oo static, vis. (std.) preliminary
73 urlIn this paper we propose new dynamic-slicing related features that exploit this information for the purpose of understanding of program execution. Korel Dynamic Program Slicing in Understanding of Program Execution IWPCInternational Workshop on Program Comprehension 1997 31 general procedural slicing, static, vis. (std.) preliminary
74 urlIn this paper we present program slicing concepts on the module level that allow for better understanding of program slices of large programs and their executions. Korel Program Slicing in Understanding of Large Programs IWPCInternational Workshop on Program Comprehension 1998 26 general procedural compr./summ., slicing, static, vis. (adv.), vis. (std.) preliminary
75 urlWe have developed a semi-automatic technique for feature location using a combination of static and dynamic program analysis. Koschke On Dynamic Feature Location ASEInternational Conference on Automated Software Engineering 2005 8 features, views procedural fca, filtering, metrics, mult. traces, static, vis. (std.) case study, comparison, quantitative
76 urlWe show how [scenario diagrams] can be used reversely for understanding and browsing existing software. Koskimies Scene: Using Scenario Diagrams and Active Text for Illustrating Object-Oriented Programs ICSEInternational Conference on Software Engineering 1996 65 general, trace, views oo compr./summ., filtering, patt. det., static, vis. (std.) preliminary
77 urlIn this paper we discuss behavioral profiles, given in UML, used to capture and illustrate architecturally significant behavioral rules. Koskinen Profile-Based Approach to Support Comprehension of Software Behavior ICPCInternational Conference on Program Comprehension 2006 3 behavior, views oo static, vis. (std.) preliminary
78 urlWe define a measurement of similarity between pairs of features based on their underlying implementations and use this measurement to compute a set of canonical features. Kothari On Computing the Canonical Features of Software Systems WCREWorking Conference on Reverse Engineering 2006 6 features oo, procedural compr./summ., mult. traces, vis. (adv.) case study
79 urlWe define a measure of feature implementation overlap that determines how similar features are in their execution by examining their call graphs. Kothari Reducing Program Comprehension Effort in Evolving Software by Recognizing Feature Implementation Convergence ICPCInternational Conference on Program Comprehension 2007 0 features oo, procedural compr./summ., metrics, mult. traces case study
80 urlIn this paper we introduce a novel approach representing entire traces as signals in time. Kuhn Exploiting the Analogy Between Traces and Signal Processing ICSMInternational Conference on Software Maintenance 2006 8 features, trace, views oo compr./summ., filtering, metrics, mult. traces, vis. (adv.) case study
81 urlIn our research, we have addressed the scalability problem by integrating static and dynamic program information to produce abstract and yet accurate views of complex O-O systems that often provide more useful information than can be obtained by reading the source code. Lange Program Explorer: A Program Visualizer for C++ COOTSConference on Object-Oriented Technology and Systems 1995 55 general, views oo filtering, querying, static, vis. (std.) preliminary
82 urlInteractive visualization of design patterns occurring in a framework shows how the framework is operating, in a flexible yet structured way that contributes to the programmer's understanding of the underlying software architecture. Lange Interactive Visualization of Design Patterns Can Help in Framework Understanding OOPSLAConference on Object-Oriented Programming Systems, Languages, & Applications 1995 96 general oo filtering, patt. det., querying, static, vis. (std.) preliminary
83 urlOur approach combines static information with actual execution information to produce views that summarize the relevant computation. Lange Object-Oriented Program Tracing and Visualization IEEEIEEE Computer 1997 55 general, views oo filtering, patt. det., slicing, static, vis. (std.) preliminary
84 urlWe introduce an inexpensive and easily comprehensible summary of program changes called the feature signature and investigate its properties. Licata The Feature Signatures of Evolving Programs ASEInternational Conference on Automated Software Engineering 2003 14 features oo compr./summ., mult. traces, static, vis. (std.) case study
85 urlIn this paper, we propose an approach to precisely identify dependencies between features based on a fine-grained dynamic analysis which captures details about how objects are referenced at runtime. Lienhard Tracking Objects to Detect Feature Dependencies ICPCInternational Conference on Program Comprehension 2007 7 features, views oo filtering, vis. (adv.) case study, comparison, quantitative
86 urlThe paper presents a semi-automated technique for feature location in source code. Liu Feature Location via Information Retrieval based Filtering of a Single Scenario Execution Trace ASEInternational Conference on Automated Software Engineering 2007 0 features, survey oo filtering, heuristics, querying, static case study, comparison, quantitative
87 urlIn this paper, we describe QUARK (QUality Assurance framewoRK) that enables assessments of the performance of a specification miner in generating temporal specification of software through traces recorded from its API interaction. Lo QUARK: Empirical Assessment of Automaton-based Specification Miners WCREWorking Conference on Reverse Engineering 2006 8 behavior, survey, views oo - case study, quantitative
88 urlIn this paper, we propose a novel API specification mining architecture called SMArTIC (Specification Mining Architecture with Trace fIltering and Clustering) to improve the accuracy, robustness and scalability of specification miners. Lo SMArTIC: Towards Building an Accurate, Robust and Scalable Specification Miner FSEEuropean Software Engineering Conference & Symposium on the Foundations of Software Engineering 2006 12 behavior, views oo compr./summ., filtering, heuristics, metrics, patt. det., vis. (std.) case study, comparison, quantitative
89 urlIn this study, we propose a novel technique to mine from program execution traces a sound and complete set of statistically significant temporal rules of arbitrary lengths. Lo Mining Temporal Rules for Software Maintenance JSMEJournal of Software Maintenance & Evolution 2008 0 - oo filtering, heuristics, patt. det. case study
90 urlThis paper presents an approach inspired by the reverse engineering arena and a tool prototype supporting WEB application reverse engineering activities, to help maintain, comprehend and evolve WEB applications. Di Lucca An Approach for Reverse Engineering of Web-Based Applications WCREWorking Conference on Reverse Engineering 2001 30 general, views web querying, static, vis. (std.) case study
91 urlThis paper presents a tool for reverse engineering Web applications. Di Lucca WARE: a tool for the Reverse Engineering of Web Applications CSMREuropean Conference on Software Maintenance & Reengineering 2002 40 general, views web querying, static, vis. (std.) case study
92 urlIn this paper, the experimentation of a reverse engineering approach is described. Di Lucca Towards a Better Comprehensibility of Web Applications: Lessons Learned from Reverse Engineering Experiments WSEInternational Workshop on Website Evolution 2002 11 general, views web compr./summ., static, vis. (std.) case study
93 urlIn this paper a reverse engineering approach for reconstructing UML diagrams at business level of the application domain of a Web Application is presented. Di Lucca Abstracting Business Level UML Diagrams from Web Applications WSEInternational Workshop on Website Evolution 2003 14 general, views web compr./summ., heuristics, static, vis. (std.) preliminary
94 urlThis paper describes a tool called TraceGraph to support [feature location], particularly for large, long-running or interactive software. Lukoit TraceGraph: Immediate Visual Location of Software Features ICSMInternational Conference on Software Maintenance 2000 26 features, views procedural online, vis. (adv.) case study, industrial
95 urlIn this paper we present an approach to modeling and visualizing the dynamic interactions among objects in a C++ application. We exploit UML diagrams to expressively visualize both the static and dynamic properties of the application. Gestwicki Exploiting UML dynamic object modeling for the visualization of C++ programs SOFTVISSymposium on Software Visualization 2005 16 general, views oo filtering, online, static, vis. (std.) preliminary
96 urlIn this paper, we explore the usefulness of dynamic program visualization for component programs. Martin Dynamic Component Program Visualization WCREWorking Conference on Reverse Engineering 2002 8 behavior, views - filtering, vis. (adv.) unknown/none
97 urlWe describe a three-step method to allow a developer to understand the run-time behavior of a distributed system. Moe Understanding Distributed Systems via Execution Trace Data IWPCInternational Workshop on Program Comprehension 2001 31 general distributed filtering, metrics, querying, vis. (adv.) preliminary
98 urlIn order to cope with this challenge, we have developed a three-step method to study the run-time behavior of a distributed system. Moe Using execution trace data to improve distributed systems SP&ESoftware -- Practice & Experience 2002 13 general distributed filtering, metrics, querying, vis. (adv.) case study, industrial
99 urlThis paper contributes two studies at Ericsson Radio Systems of the perfective maintenance of large and distributed systems. Moe Using Execution Trace Data to Improve Distributed Systems ICSMInternational Conference on Software Maintenance 2002 13 general distributed filtering, metrics, patt. det., querying, vis. (adv.) case study, industrial
100 urlThe goal of the JAVAVIS system is to help students understand what is happening in a Java program during execution. Oechsle JAVAVIS: Automatic Program Visualization with Object and Sequence Diagrams Using the Java Debug Interface (JDI) SOFTVISSymposium on Software Visualization 2001 44 general, views oo, threads filtering, vis. (std.) preliminary
101 urlIn this paper, we present a new technique for collecting, storing, and visualizing program-execution data gathered from deployed instances of a software product. Orso Visualization of Program-Execution Data for Deployed Software SOFTVISSymposium on Software Visualization 2003 33 general, views oo compr./summ., filtering, static, vis. (adv.) case study, preliminary
102 urlThis paper presents an empirical evaluation of five dynamic visualisation tools AVID, Jinsight, jRMTool, Together ControlCenter diagrams and Together ControlCenter debugger. Pacione A Comparative Evaluation of Dynamic Visualisation Tools WCREWorking Conference on Reverse Engineering 2003 17 general, survey, views oo vis. (adv.), vis. (std.) case study
103 urlThis paper proposes a novel software visualisation model for supporting object-oriented software comprehension that is intended to address the shortcomings of existing tools. Pacione A Novel Software Visualisation Model to Support Software Comprehension WCREWorking Conference on Reverse Engineering 2004 14 general oo static preliminary
104 urlWe introduce novel views of the behavior of object-oriented systems and an architecture for creating and animating these views. De Pauw Visualizing the Behavior of Object-Oriented Systems OOPSLAConference on Object-Oriented Programming Systems, Languages, & Applications 1993 126 general, views oo vis. (adv.) unknown/none
105 urlThis paper describes a way of organizing information about an object-oriented program's execution. De Pauw Modeling Object-Oriented Program Execution ECOOPEuropean Conference on Object-Oriented Programming 1994 77 general, views oo querying, vis. (adv.) preliminary
106 urlWe present an execution pattern view that lets a programmer visualize and explore a program's execution at varied levels of abstraction. De Pauw Execution Patterns in Object-Oriented Visualization COOTSConference on Object-Oriented Technology and Systems 1998 77 general, trace, views oo filtering, heuristics, patt. det., vis. (adv.), vis. (std.) preliminary
107 urlJinsight is a tool for exploring a program's run-time behavior visually. De Pauw Visualizing the Execution of Java Programs SOFTVISSymposium on Software Visualization 2001 56 general, trace, views oo, threads patt. det., vis. (adv.) preliminary
108 urlWe present a pattern-based visualization that enables business owners, application designers, programmers, and operations staff to quickly understand the behavior of complex web services applications. De Pauw Execution Patterns for Visualizing Web Services SOFTVISSymposium on Software Visualization 2006 6 general, views distributed, web patt. det., vis. (adv.) preliminary
109 urlWe have designed and implemented a dynamic heap analysis system that allows one to examine and analyze how Java programs build and modify data structures. Pheng Dynamic Data Structure Analysis for Java Programs ICPCInternational Conference on Program Comprehension 2006 3 general oo heuristics, static, vis. (std.) case study
110 urlThe paper recasts the problem of feature location in source code as a decision-making problem in the presence of uncertainty. The main contribution consists in the combination of two existing techniques for feature location in source code. Poshyvanyk Combining Probabilistic Ranking and Latent Semantic Indexing for Feature Identification ICPCInternational Conference on Program Comprehension 2006 17 features oo filtering, heuristics, metrics, mult. traces, static case study, comparison
111 urlThis paper recasts the problem of feature location in source code as a decision-making problem in the presence of uncertainty. [...] The experts in this work are two existing techniques for feature location: a scenario-based probabilistic ranking of events and an information-retrieval-based technique that uses Latent Semantic Indexing. Poshyvanyk Feature Location Using Probabilistic Ranking of Methods Based on Execution Scenarios and Information Retrieval TSEIEEE Transactions on Software Engineering 2007 5 features oo filtering, heuristics, metrics, mult. traces, static case study, comparison, quantitative
112 urlThis paper deals with the problems of architecture recovery from the perspective of process. Qingshan Architecture Recovery and Abstraction from the Perspective of Processes WCREWorking Conference on Reverse Engineering 2005 0 design/arch., views oo slicing, static, vis. (std.) case study
113 urlThis paper describes a new technique to extract object process graphs through dynamic analysis and discusses several applications. Quante Dynamic Object Process Graphs CSMREuropean Conference on Software Maintenance & Reengineering 2006 4 behavior, views procedural filtering, slicing, vis. (std.) case study
114 urlIn this paper, we introduce an alternative way of collecting the necessary data. By constructing an intermediate graph online, i.e., concurrently with the running program, the trace size problem is eliminated. Quante Online Construction of Dynamic Object Process Graphs CSMREuropean Conference on Software Maintenance & Reengineering 2007 1 behavior, views oo, threads filtering, online, vis. (std.) case study, comparison, quantitative
115 urlThis article describes a new technique to extract object process graphs through dynamic analysis and discusses several applications, in particular program understanding and protocol recovery. Quante Dynamic Object Process Graphs JSSJournal of Systems & Software 2008 0 behavior, general, views procedural filtering, slicing, vis. (std.) case study, comparison, quantitative
116 urlWe introduce a new dynamic protocol recovery technique based on object process graphs. Quante Dynamic Protocol Recovery WCREWorking Conference on Reverse Engineering 2007 0 behavior, views oo, procedural compr./summ., filtering, metrics, patt. det., vis. (std.) case study, comparison, quantitative
117 urlWe report on a controlled experiment which investigated this question: Does the availability of [dynamic object process graphs] support program understanding or not? Quante Do Dynamic Object Process Graphs Support Program Understanding? -- A Controlled Experiment ICPCInternational Conference on Program Comprehension 2008 0 features, general, views oo compr./summ., filtering, vis. (std.) case study, human subj.
118 urlWe address this problem in two phases: the first phase selects subsets of the data and then compacts it, while the second phase encodes the data in an attempt to infer its structure. Reiss Encoding Program Executions ICSEInternational Conference on Software Engineering 2001 100 trace oo compr./summ., patt. det., vis. (std.) case study, quantitative
119 urlAs part of our software visualization and analysis efforts we have developed a system that lets the programmer define what is meant by an event and then to track the resources used in processing that event through the system. Reiss Event-based Performance Analysis IWPCInternational Workshop on Program Comprehension 2003 4 general, views oo vis. (adv.) preliminary
120 urlWe have developed a dynamic Java visualizer that provides a view of a program in action with low enough overhead so that it can be used almost all the time by programmers to understand what their program is doing while it is doing it. Reiss Visualizing Java in Action SOFTVISSymposium on Software Visualization 2003 34 general, views oo, threads compr./summ., online, static, vis. (adv.) case study
121 urlJIVE is a system that tries to answer this question. It provides insights into the execution of Java programs. Reiss Efficient Monitoring and Display of Thread State in Java IWPCInternational Workshop on Program Comprehension 2005 4 general, views oo, threads compr./summ., online, static, vis. (adv.) case study
122 urlWe have developed a dynamic Java visualizer that provides a statement-level view of a Java program in action with low enough overhead so that it can be used almost all the time by programmers to understand what their program is doing while it is doing it. Reiss JOVE: Java as it Happens SOFTVISSymposium on Software Visualization 2005 14 general, views oo, threads compr./summ., online, static, vis. (adv.) case study
123 urlThis paper describes a visualization data model and its implementation that accomplishes [offering user views of the execution that are specific to the program and problem]. Reiss Visualizing Program Execution Using User Abstractions SOFTVISSymposium on Software Visualization 2006 2 general, views oo, threads compr./summ., online, static, vis. (adv.) case study
124 urlThis paper looks at the evolution of on-line visual representations of executing programs, showing how they have moved from concrete representations of relatively small programs to abstract representations of larger systems. Reiss Visual representations of executing programs JVLCJournal of Visual Languages & Computing 2007 2 general, survey, views oo, procedural, threads vis. (adv.), vis. (std.) unknown/none
125 urlWe present our first attempt to visualize trace data for exploration purposes. Renieris Almost: Exploring Program Traces NPIVMWorkshop on New Paradigms in Information Visualization and Manipulation 1999 27 trace, views procedural filtering, querying, static, vis. (adv.) preliminary
126 urlIn this paper we present an environment supporting the generation of tailorable views of object-oriented systems from both static and dynamic information. Richner Recovering High-Level Views of Object-Oriented Applications from Static and Dynamic Information ICSMInternational Conference on Software Maintenance 1999 104 design/arch., views oo compr./summ., querying, static, vis. (std.) case study
127 urlIn this paper we propose an iterative approach which uses dynamic information to support the recovery and understanding of collaborations. Richner Using Dynamic Information for the Iterative Recovery of Collaborations and Roles ICSMInternational Conference on Software Maintenance 2002 60 general, views oo filtering, patt. det., querying, vis. (adv.) case study
128 urlIn this paper, we present our task and user-centered comprehension environment that maximizes the functional cohesion among the tools and comprehension techniques by focusing on a particular user task and its appropriate comprehension strategy. Rilling Maximizing Functional Cohesion of Comprehension Environments by Integrating User and Task Knowledge WCREWorking Conference on Reverse Engineering 2001 4 general, views oo compr./summ., filtering, metrics, slicing, static, vis. (std.) unknown/none
129 urlThe following paper describes a tool-supported approach to extracting information about programs via a dynamic analysis of the program behaviour. Ritsch Reverse Engineering Programs via Dynamic Analysis WCREWorking Conference on Reverse Engineering 1993 14 general legacy static preliminary
130 urlThis paper presents our experience in recovering the architecture of an embedded software system developed in Nokia. Riva Reverse Architecting: an Industrial Experience Report WCREWorking Conference on Reverse Engineering 2000 47 design/arch., views procedural compr./summ., metrics, static, vis. (std.) industrial
131 urlWe propose a technique for combining the analysis of static and dynamic architectural information to support the task of architecture reconstruction. Riva Combining Static and Dynamic Views for Architecture Reconstruction CSMREuropean Conference on Software Maintenance & Reengineering 2002 30 design/arch., views procedural compr./summ., filtering, slicing, static, vis. (std.) preliminary
132 urlIn this article, we present our XML based approach for generating the architectural documentation of a software system. Riva Generation of Architectural Documentation using XML WCREWorking Conference on Reverse Engineering 2002 9 design/arch., views procedural compr./summ., static, vis. (std.) preliminary
133 urlIn this paper, we present a novel approach for feature location that combines static and dynamic analysis techniques. Rohatgi An Approach for Mapping Features to Code Based on Static and Dynamic Analysis ICPCInternational Conference on Program Comprehension 2008 0 features oo filtering, heuristics, metrics, static preliminary
134 urlWe therefore propose a declarative platform wherein behavioral program models can be expressed in terms of userdefined high-level concepts and be automatically verified against an application's actual behavior. De Roover An Approach to High-Level Behavioral Program Documentation Allowing Lightweight Verification ICPCInternational Conference on Program Comprehension 2006 4 behavior procedural static case study
135 urlWe propose to enhance IDEs with a program's runtime information (e.g., message sends and type information) to support program comprehension through precise navigation and informative browsing. Röthlisberger Exploiting Runtime Information in the IDE ICPCInternational Conference on Program Comprehension 2008 0 general oo filtering, static case study, human subj.
136 urlIn this paper, we propose a novel technique for dynamic analysis of software systems to identify the implementation of the software features that are specified through a number of feature-specific task scenarios. Safyallah Dynamic Analysis of Software Systems using Execution Pattern Mining ICPCInternational Conference on Program Comprehension 2006 3 features procedural mult. traces, patt. det., static preliminary
137 urlThis paper presents the results of the first phase of a project to develop an environment that supports the comprehension of distributed systems. Salah Toward an environment for comprehending distributed systems WCREWorking Conference on Reverse Engineering 2003 11 general, views distributed querying, static, vis. (std.) preliminary
138 urlThis paper presents a hierarchy of dynamic views that is constructed using tools that analyze program execution traces. Salah A Hierarchy of Dynamic Software Views: from Object-Interactions to Feature-Interactions ICSMInternational Conference on Software Maintenance 2004 17 features, views oo compr./summ., filtering, mult. traces, querying, static, vis. (std.) case study
139 urlThis paper describes a new approach and a tool for generating class usage scenarios (i.e., how a class is used by other classes) from method invocations, which are collected during the execution of the software. Salah Scenariographer: A Tool for Reverse Engineering Class Usage Scenarios from Method Invocation Sequences ICSMInternational Conference on Software Maintenance 2005 8 features oo compr./summ., metrics, mult. traces, patt. det., querying case study
140 urlThis paper presents an approach for comprehending large software systems using views that are created by subjecting the software systems to dynamic analysis under various use-case scenarios. Salah Towards Employing Use-cases and Dynamic Analysis to Comprehend Mozilla ICSMInternational Conference on Software Maintenance 2005 7 features, views oo compr./summ., metrics, mult. traces, vis. (std.) preliminary
141 urlThis paper presents an approach that uses dynamic analysis to extract views of a software system at different levels Salah Scenario-Driven Dynamic Analysis for Comprehending Large Software Systems CSMREuropean Conference on Software Maintenance & Reengineering 2006 4 features, views oo compr./summ., metrics, mult. traces, patt. det., querying, vis. (std.) case study
142 urlThe proposed technique in this paper is based on extracting frequent patterns in the execution traces of a software system using a pattern discovery technique. Sartipi Application of Execution Pattern Mining and Concept Lattice Analysis on Software Structure Evaluation SEKEInternational Conference on Software Engineering & Knowledge Engineering 2006 2 features procedural compr./summ., fca, filtering, metrics, patt. det., static, vis. (std.) case study, quantitative
143 urlWe propose an orchestrated set of techniques and a multi-view toolkit to reconstruct three views of a software system such as design, behavior, and structure. Sartipi An Orchestrated Multi-view Software Architecture Reconstruction Environment WCREWorking Conference on Reverse Engineering 2006 3 design/arch., features, views procedural compr./summ., fca, patt. det., static, vis. (std.) case study
144 urlIn this paper, we propose a novel approach that amalgamates dynamic and static views of a software system. Sartipi An Amalgamated Dynamic and Static Architecture Reconstruction Framework to Control Component Interactions WCREWorking Conference on Reverse Engineering 2007 0 design/arch., features, views procedural metrics, patt. det., querying, static, vis. (std.) case study
145 urlIn this paper we describe a technique that uses run time observations about an executing system to construct an architectural view of the system. Yan DiscoTect: A System for Discovering Architectures from Running Systems ICSEInternational Conference on Software Engineering 2004 37 behavior, design/arch., views oo filtering, patt. det., querying, vis. (std.) case study
146 urlIn this paper, we describe a technique that uses runtime observations about an executing system to construct an architectural view of the system. Schmerl Discovering Architectures from Running Systems TSEIEEE Transactions on Software Engineering 2006 8 behavior, design/arch., views oo filtering, patt. det., querying, vis. (std.) case study
147 urlThis paper shows that architecture-oriented visualization, the graphical presentation of system statics and dynamics in terms of its architectural abstractions, is highly beneficial in designing complex systems. Sefika Architecture-Oriented Visualization OOPSLAConference on Object-Oriented Programming Systems, Languages, & Applications 1996 40 design/arch., views oo filtering, querying, static, vis. (std.) case study, quantitative
148 urlIn this paper we propose the first step in achieving this goal by presenting a dynamic analysis tool, called PEXT, that can reverse engineer a networked application's underlying protocol by analyzing a collection of packets captured from the application at runtime. Shevertalov A Reverse Engineering Tool for Extracting Protocols of Networked Applications WCREWorking Conference on Reverse Engineering 2007 0 behavior, views legacy compr./summ., filtering, vis. (std.) unknown/none
149 urlThis article describes a study performed with Motorola, Inc. to see whether there were any pitfalls in using Metrowerks CodeTEST and Klocwork inSight for feature location on message-passing software similar to systems that Motorola maintains. Simmons Industrial tools for the feature location problem: an exploratory study JSMEJournal of Software Maintenance & Evolution 2006 4 features, views procedural mult. traces, static, vis. (std.) case study, human subj., quantitative
150 urlWe present a methodology and a toolkit for redocumenting the use cases of interactive Java Swing object-oriented applications. Smit Use Case Redocumentation from GUI Event Traces CSMREuropean Conference on Software Maintenance & Reengineering 2008 0 behavior, views oo compr./summ., filtering, metrics, mult. traces, vis. (std.) case study
151 urlIn this paper we describe the Form architecture and implementation, as well as a tool that was built using Form. Souder Form: A Framework for Creating Views of Program Executions ICSMInternational Conference on Software Maintenance 2001 21 general, views distributed, oo filtering, vis. (std.) preliminary
152 urlThis paper presents a reverse engineering environment to support extraction and detection of implied scenarios from execution traces. Sousa Detecting Implied Scenarios from Execution Traces WCREWorking Conference on Reverse Engineering 2007 0 - oo, web filtering, patt. det., vis. (std.) case study
153 urlIn this paper, we present a method for reverse engineering the system interface that consists of two tasks Stroulia Reverse Engineering Legacy Interfaces: An Interaction-Driven Approach WCREWorking Conference on Reverse Engineering 1999 25 behavior legacy compr./summ., filtering, mult. traces unknown/none
154 urlAn experimental environment for reverse engineering Java software is discussed. Systä On the Relationships between Static and Dynamic Models in Reverse Engineering Java Software WCREWorking Conference on Reverse Engineering 1999 48 general, views oo slicing, static, vis. (std.) case study
155 urlWe show how [Chidamber and Kemerer's object-oriented metrics] can be applied in the context of understanding software systems using a reverse engineering environment. Systä Analyzing Java Software by Combining Metrics and Program Visualization CSMREuropean Conference on Software Maintenance & Reengineering 2000 42 general, views oo metrics, patt. det., querying, slicing, static, vis. (std.) case study
156 urlThis paper demonstrates how Shimba aids understanding the behavior of Java programs. Systä Understanding the Behavior of Java Programs WCREWorking Conference on Reverse Engineering 2000 45 general, trace, views oo, threads patt. det., querying, slicing, static, vis. (std.) case study
157 urlShimba 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. Systä Shimba: an environment for reverse engineering Java software systems SP&ESoftware -- Practice & Experience 2001 65 general, trace, views oo, threads metrics, patt. det., querying, slicing, static, vis. (std.) case study
158 urlIn this paper a novel static analysis algorithm is proposed for the extraction of the object diagram from the code, based on a program representation called the object flow graph. Tonella Static and Dynamic C++ Code Analysis for the Recovery of the Object Diagram ICSMInternational Conference on Software Maintenance 2002 10 general, views oo static, vis. (std.) case study
159 urlIn this paper, we describe [an off-line, flexible approach for visualizing the operation of an object-oriented system at the architectural level] and discuss preliminary qualitative studies into its usefulness and usability. Walker Visualizing Dynamic Software System Information through High-level Models OOPSLAConference on Object-Oriented Programming Systems, Languages, & Applications 1998 103 general, views oo filtering, querying, vis. (std.) preliminary
160 urlIn this paper, we present an encoding technique for dynamic trace information that makes it tractable and efficient to manipulate a trace from a variety of different architecture-level viewpoints. Walker Efficient Mapping of Software System Traces to Architectural Views CASCONConference of the Centre for Advanced Studies on Collaborative Research 2000 26 general, views oo compr./summ., filtering, querying, vis. (std.) unknown/none
161 urlThis paper describes (1) how an existing grammar inference technique (QSM) can be used to reverse-engineer state-based models of software from execution traces at a developer-defined level of abstraction and (2) how the QSM technique can be improved for a better balance between the number of tests it proposes and the accuracy of the machine it derives. Walkinshaw Reverse Engineering State Machines by Interactive Grammar Inference WCREWorking Conference on Reverse Engineering 2007 0 behavior oo patt. det., querying, vis. (std.) case study
162 urlThis paper investigates the similarities [between solutions for inferring grammars from (sparse) information] and shows how many of these advances can be applied with similar effect to dynamic analysis problems by a series of small experiments on random state machines. Walkinshaw Improving Dynamic Software Analysis by Applying Grammar Inference Principles JSMEJournal of Software Maintenance & Evolution 2008 0 behavior oo compr./summ., metrics, patt. det., querying, static, vis. (std.) case study
163 urlIn this paper, we introduce DPVK (Design Pattern Verification toolKit), the first reverse engineering tool to detect pattern instances in Eiffel systems. Wang Design Pattern Detection in Eiffel Systems WCREWorking Conference on Reverse Engineering 2005 2 design/arch. oo patt. det., querying, static case study, quantitative
164 urlThis paper describes four case studies applying Reconnaissance to three different industrial programs of moderate size. Wilde Early Field Experience with the Software Reconnaissance Technique for Program Comprehension ICSMInternational Conference on Software Maintenance 1996 38 features, general procedural heuristics, metrics, mult. traces case study, industrial
165 urlThis paper presents several dynamic analysis methods for addressing [the Year 2000] problem. Wilde Dynamic Analysis Methods for the Year 2000 Problem JSMEJournal of Software Maintenance & Evolution 1999 1 general procedural heuristics, metrics, mult. traces preliminary
166 urlThis report describes preliminary experiences in adapting [two methods to help locate features: Software Reconnaissance and Dependency Graph] to legacy Fortran code typical of systems developed in the 1970's. Wilde A Case Study of Feature Location in Unstructured Legacy Fortran Code CSMREuropean Conference on Software Maintenance & Reengineering 2001 25 features legacy, procedural - comparison, human subj., industrial
167 urlThis paper describes a case study to locate two features in a sample of poorly structured legacy Fortran code. Wilde A Comparison of Methods for Locating Features in Legacy Software JSSJournal of Systems & Software 2003 30 features legacy, procedural - comparison, human subj., industrial
168 urlThis paper presents a method, called 'software reconnaissance' for [discovering where particular features are implemented] through an analysis of the execution of different test cases. Wilde Software Reconnaissance: Mapping Program Features to Code JSMEJournal of Software Maintenance & Evolution 1995 159 features procedural heuristics, metrics, mult. traces human subj., preliminary
169 urlIn this paper we report a study applying an execution slice-based technique to a reliability and performance evaluator to identify the code which is unique to a feature, or is common to a group of features. Wong Locating Program Features using Execution Slices ASSETSymposium on Application-Specific Systems and Software Engineering and Technology 1999 55 features procedural heuristics, slicing, static, vis. (std.) case study, quantitative
170 urlIn this paper, we use an execution slice-based technique to identify the basic blocks which are used to implement a program feature. Wong Quantifying the Closeness Between Program Components and Features JSSJournal of Systems & Software 2000 32 features procedural heuristics, metrics, slicing, static case study, quantitative
171 urlIn this paper we present metrics to determine the distance between the features of a software system. Wong Static and dynamic distance metrics for feature-based code analysis JSSJournal of Systems & Software 2005 6 features procedural heuristics, metrics, slicing, static case study, quantitative
172 urlTherefore, this paper proposes a heuristic which divides the trace data into recurring event clusters Zaidman Managing trace data volume through a heuristical clustering process based on event execution frequency CSMREuropean Conference on Software Maintenance & Reengineering 2004 22 trace oo compr./summ., filtering, heuristics, metrics, vis. (adv.) case study
173 urlWe propose a technique that uses webmining principles on execution traces to discover these important and tightly interacting classes. Zaidman Applying Webmining Techniques to Execution Traces to Support the Program Comprehension Process CSMREuropean Conference on Software Maintenance & Reengineering 2005 32 general oo heuristics, metrics case study
174 urlHere, we reprise this webmining technique and make a thorough comparison of its effectiveness when collecting static information of the software system under study. Zaidman How Webmining and Coupling Metrics Improve Early Program Comprehension ICPCInternational Conference on Program Comprehension 2006 2 general oo heuristics, metrics, static case study
175 urlWe propose a technique that uses webmining principles on execution traces to discover these important and tightly interacting classes. We now also compare our previous dynamic approach with a similar static approach. Zaidman Automatic Identification of Key Classes in a Software System Using Webmining Techniques JSMEJournal of Software Maintenance & Evolution 2008 0 general oo heuristics, metrics, static case study, quantitative
176 urlThis paper describes our experiences of applying dynamic analysis solutions on an industrial legacy application written in C, with the help of Aspect Orientation (AO). Zaidman Regaining Lost Knowledge through Dynamic Analysis and Aspect Orientation CSMREuropean Conference on Software Maintenance & Reengineering 2006 11 general, trace legacy, procedural heuristics, metrics, vis. (adv.) industrial

Valid HTML 4.01 Transitional