Compilers: principles, techniques, and tools
Compilers: principles, techniques, and tools
Program evolution: processes of software change
Program evolution: processes of software change
The program dependence graph and its use in optimization
ACM Transactions on Programming Languages and Systems (TOPLAS)
A mechanism for specifying the structure of large, layered systems
Research directions in object-oriented programming
Detecting conflicts between structure accesses
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Integrating noninterfering versions of programs
ACM Transactions on Programming Languages and Systems (TOPLAS)
Interprocedural slicing using dependence graphs
ACM Transactions on Programming Languages and Systems (TOPLAS)
An interval-based approach to exhaustive and incremental interprocedural data-flow analysis
ACM Transactions on Programming Languages and Systems (TOPLAS)
Analysis of pointers and structures
PLDI '90 Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation
An efficient hybrid algorithm for incremental data flow analysis
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The C++ programming language (2nd ed.)
The C++ programming language (2nd ed.)
Using Program Slicing in Software Maintenance
IEEE Transactions on Software Engineering
Reconciling environment integration and software evolution
ACM Transactions on Software Engineering and Methodology (TOSEM)
SDE 5 Proceedings of the fifth ACM SIGSOFT symposium on Software development environments
Program restructuring as an aid to software maintenance
Program restructuring as an aid to software maintenance
Automated assistance for program restructuring
ACM Transactions on Software Engineering and Methodology (TOSEM)
Interprocedural modification side effect analysis with pointer aliasing
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
Direct update of data flow representations for a meaning-preserving program restructuring tool
SIGSOFT '93 Proceedings of the 1st ACM SIGSOFT symposium on Foundations of software engineering
Automated support for encapsulating abstract data types
SIGSOFT '94 Proceedings of the 2nd ACM SIGSOFT symposium on Foundations of software engineering
Managing design trade-offs for a program understanding and transformation tool
Journal of Systems and Software - Double issue on reengineering complex systems
Mediators: easing the design and evolution of integrated systems
Mediators: easing the design and evolution of integrated systems
The structuring of systems using upcalls
Proceedings of the tenth ACM symposium on Operating systems principles
Modularization and hierarchy in a family of operating systems
Communications of the ACM
The structure of the “THE”-multiprogramming system
Communications of the ACM
Dependence graphs and compiler optimizations
POPL '81 Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the First JSSST International Symposium on Object Technologies for Advanced Software
Adding Implicit Invocation to Languages: Three Approaches
Proceedings of the First JSSST International Symposium on Object Technologies for Advanced Software
Restructuring Symbolic Programs for Concurrent Execution on
Restructuring Symbolic Programs for Concurrent Execution on
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
The design of whole-program analysis tools
Proceedings of the 18th international conference on Software engineering
Programming language requirements for the next millennium
ACM Computing Surveys (CSUR) - Special issue: position statements on strategic directions in computing research
Just-in-time architecture: planning software in an uncertain world
ISAW '96 Joint proceedings of the second international software architecture workshop (ISAW-2) and international workshop on multiple perspectives in software development (Viewpoints '96) on SIGSOFT '96 workshops
Intent Specifications: An Approach to Building Human-Centered Specifications
IEEE Transactions on Software Engineering
Modular verification of collaboration-based software designs
Proceedings of the 8th European software engineering conference held jointly with 9th ACM SIGSOFT international symposium on Foundations of software engineering
Software Reflexion Models: Bridging the Gap between Design and Implementation
IEEE Transactions on Software Engineering
Coping with Crosscutting Software Changes Using Information Transparency
REFLECTION '01 Proceedings of the Third International Conference on Metalevel Architectures and Separation of Crosscutting Concerns
A case study in re-engineering to enforce architectural control flow and data sharing
Journal of Systems and Software
Hi-index | 0.00 |
Maintaining the consistency of multiple program representations驴such as abstract syntax trees and program dependence graphs驴in a program manipulation tool is difficult. This paper describes a hybrid software architecture for a meaning-preserving program restructuring tool. Layering is the primary architectural paradigm, which successively provides increasingly integrated and unified abstract machines to implement the tool. However, layering does not provide adequate control over extensibility or the independence of components. Consequently, we also adopted the paradigm of keeping the key program abstractions separate throughout the layering, providing independent 驴columns驴 of abstract data types. A pair of columns is integrated by a mapping column that translates elements in one column's data type into related elements in the other column's data type. Thus integration of function and separation of representation can be achieved simultaneously in this complex domain.This hybrid architecture was crucial in overcoming severe performance problems驴classic in traditional layered systems驴 that became apparent once the basic tool was completed. By taking advantage of the independence of the columns and the special characteristics of meaning-preserving restructuring, it was possible to extend one representation column of the architecture to the uppermost layer to provide the required access for efficient update without compromising independence. The cost of the extended architecture is that the upper layers are no longer as simple because they expose operations that only guarantee consistency under careful usage. However, the structural constraints of the hybrid architecture and provided models for building the more complicated layers minimizes the negative impact of this tradeoff.