System Structure Analysis: Clustering with Data Bindings
IEEE Transactions on Software Engineering - Annals of discrete mathematics, 24
Rigi-A system for programming-in-the-large
ICSE '88 Proceedings of the 10th international conference on Software engineering
Software reflexion models: bridging the gap between source and high-level models
SIGSOFT '95 Proceedings of the 3rd ACM SIGSOFT symposium on Foundations of software engineering
Reverse engineering to the architectural level
Proceedings of the 17th international conference on Software engineering
Identification of Dynamic Comprehension Processes During Large Scale Maintenance
IEEE Transactions on Software Engineering - Special issue: best papers of the 17th International Conference on Software Engineering (ICSE-17)
Practical reusable UNIX software
Microsoft Secrets: How the World's Most Powerful Software Company Creates Technology, Shapes Markets, and Manages People
Lightweight structural summarization as an aid to software evolution
Lightweight structural summarization as an aid to software evolution
Visualizing dynamic software system information through high-level models
Proceedings of the 13th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Finding refactorings via change metrics
OOPSLA '00 Proceedings of the 15th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Software Reflexion Models: Bridging the Gap between Design and Implementation
IEEE Transactions on Software Engineering
Efficient mapping of software system traces to architectural views
CASCON '00 Proceedings of the 2000 conference of the Centre for Advanced Studies on Collaborative research
An Approach for Measuring Software Evolution Using Source Code Features
APSEC '99 Proceedings of the Sixth Asia Pacific Software Engineering Conference
Tool Support for Testing and Documenting Framework-Based Software
TOOLS '99 Proceedings of the Technology of Object-Oriented Languages and Systems
Human Factors in Visualization Research
IEEE Transactions on Visualization and Computer Graphics
Reengineering towards components using "Reconn-exion"
Proceedings of the 10th European software engineering conference held jointly with 13th ACM SIGSOFT international symposium on Foundations of software engineering
Automated clustering to support the reflexion method
Information and Software Technology
Automatic modularity conformance checking
Proceedings of the 30th international conference on Software engineering
An industrial case study of architecture conformance
Proceedings of the Second ACM-IEEE international symposium on Empirical software engineering and measurement
Software Engineering
Journal of Systems and Software
Automated Architecture Consistency Checking for Model Driven Software Development
QoSA '09 Proceedings of the 5th International Conference on the Quality of Software Architectures: Architectures for Adaptive Software Systems
Extending the reflexion method for consolidating software variants into product lines
Software Quality Control
Assessing architectural drift in commercial software development: a case study
Software—Practice & Experience
Characterizing real-time reflexion-based architecture recovery: an in-vivo multi-case study
Proceedings of the 8th international ACM SIGSOFT conference on Quality of Software Architectures
Human-computer interaction in evolutionary visual software analytics
Computers in Human Behavior
Hi-index | 4.10 |
Reengineering large and complex software systems is often very costly. Reflexion models let software engineers begin with a structural high-level model that they can selectively refine to rapidly gain task-specific knowledge about the source code. In this article we give an overview of our technique and then relate how a Microsoft engineer used it to aid an experimental reengineering of Excel-a product that comprises about 1.2 million lines of C code. Our technique begins with a high-level model, which users define on the basis of a desired software engineering task. Thus, the next steps in our technique are to extract a model of the source, define a map, and, through a set of computation tools, compare the two models. This lets software engineers effectively validate their high-level reasoning with information from the source code. To satisfy the need for a quick and inexpensive method, we made the technique "lightweight" and iterative. The user can easily and rapidly access the structural information of interest and can balance the cost of refinement with the potential benefits of a more complete and accurate model. The engineer in our case study-a developer with 10-plus years at Microsoft-specified and computed an initial reflexion model of Excel in a day and then spent four weeks iteratively refining it. He estimated that gaining the same degree of familiarity with the Excel source code might have taken up to two years with other available approaches. The experimental reengineering case study shows that our technique has practical application. First, the engineer chose to use the technique even when facing extreme pressure. Second, he continued to use the technique beyond the original time (one month) to refine additional parts of the reflexion model for Excel and to compute reflexion models for successive Excel versions. Finally, the engineer stated that the slowdowns he did encounter while performing the experimental reengineering were often due to a lack of up-front understanding. Had the reflexion model technique been used more during planning, he felt that he might have understood the product better to begin with. We believe our technique was successful in large part because it uses approximation. This ensures a smooth feedback from the time invested in applying the technique to the results. The more time the Microsoft engineer spent refining the map, the more information he derived. Although this curve is not completely smooth, the engineer was able to gauge the accuracy of the results and use that information to manage the time and effort invested in using the technique.