Automated assistance for program restructuring
ACM Transactions on Software Engineering and Methodology (TOSEM)
A refactoring tool for Smalltalk
Theory and Practice of Object Systems - Special issue object-oriented software evolution and re-engineering
Cache-conscious structure definition
Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation
Identifying objects using cluster and concept analysis
Proceedings of the 21st international conference on Software engineering
Refactoring: improving the design of existing code
Refactoring: improving the design of existing code
Understanding class hierarchies using concept analysis
ACM Transactions on Programming Languages and Systems (TOPLAS)
Dynamically Discovering Likely Program Invariants to Support Program Evolution
IEEE Transactions on Software Engineering - Special issue on 1999 international conference on software engineering
Formal Concept Analysis: Mathematical Foundations
Formal Concept Analysis: Mathematical Foundations
Automated Support for Program Refactoring using Invariants
ICSM '01 Proceedings of the IEEE International Conference on Software Maintenance (ICSM'01)
Practical analysis for refactoring
Practical analysis for refactoring
Refactoring class hierarchies with KABA
OOPSLA '04 Proceedings of the 19th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Aspect Mining through the Formal Concept Analysis of Execution Traces
WCRE '04 Proceedings of the 11th Working Conference on Reverse Engineering
| Hi-index | 0.00 |
Refactoring usually involves statically analyzing source code to understand which transformations safely preserve execution behavior of the program. However, static analysis may not scale well for large programs when analysis results are too general, when tools for analyzing the source code are unwieldy, or when the tools simply do not exist. In such cases, it can be simpler to analyze the program at runtime to gather answers needed for safe code changes. I show how dynamic data can guide refactoring of a single data structure into a hierarchy of classes. Specifically, I show how I refactored the gcc compiler to cut its use of heap memory. In order to partition the declaration data structure into more efficiently-sized parts, I used data structure field access traces to automatically identify how the data structure might be refactored. I also identified other potential refactorings of the data structure using concept analysis. These results then guided by-hand modifications to the compiler. I finally evaluated what size test cases would be needed to gather adequate information to correctly perform the refactoring. The case study showed the refactoring could be performed with the dynamic information, but without traces from an exhaustive set of test cases, some fields would be moved incorrectly.