Empirically analyzing software Reuse in a production environment
Software reuse: emerging technology
OOPSLA/ECOOP '90 Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications
The design and implementation of hierarchical software systems with reusable components
ACM Transactions on Software Engineering and Methodology (TOSEM)
Subject-oriented programming: a critique of pure objects
OOPSLA '93 Proceedings of the eighth annual conference on Object-oriented programming systems, languages, and applications
SIGSOFT '93 Proceedings of the 1st ACM SIGSOFT symposium on Foundations of software engineering
Design patterns: elements of reusable object-oriented software
Design patterns: elements of reusable object-oriented software
The Effects of Layering and Encapsulation on Software Development Cost and Quality
IEEE Transactions on Software Engineering
Software architecture: perspectives on an emerging discipline
Software architecture: perspectives on an emerging discipline
Using role components in implement collaboration-based designs
Proceedings of the 11th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
On the criteria to be used in decomposing systems into modules
Communications of the ACM
Architectural Mismatch: Why Reuse Is So Hard
IEEE Software
Architectural Mismatch: Why Reuse Is So Hard
IEEE Software
Beyond the Black Box: Open Implementation
IEEE Software
Object-Oriented Software Evolution
IEEE Transactions on Software Engineering
An Object-Oriented Language-Database Integration Model: The Composition-Filters Approach
ECOOP '92 Proceedings of the European Conference on Object-Oriented Programming
Minimizing Dependency on Class Structures with Adaptive Programs
Proceedings of the First JSSST International Symposium on Object Technologies for Advanced Software
Using C++ Templates to Implement Role-Based Designs
ISOTAS '96 Proceedings of the Second JSSST International Symposium on Object Technologies for Advanced Software
Using role components in implement collaboration-based designs
Proceedings of the 11th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Open implementation analysis and design
Proceedings of the 1997 symposium on Software reusability
Experience report: using RESOLVE/C++ for commercial software
SIGSOFT '00/FSE-8 Proceedings of the 8th ACM SIGSOFT international symposium on Foundations of software engineering: twenty-first century applications
ACM Transactions on Software Engineering and Methodology (TOSEM)
Mixin-Based Programming in C++
GCSE '00 Proceedings of the Second International Symposium on Generative and Component-Based Software Engineering-Revised Papers
The Architectural Style of Component Programming
COMPSAC '97 Proceedings of the 21st International Computer Software and Applications Conference
Coping with Crosscutting Software Changes Using Information Transparency
REFLECTION '01 Proceedings of the Third International Conference on Metalevel Architectures and Separation of Crosscutting Concerns
Implementing Collaboration-Based Designs Using Aspect-Oriented Programming
TOOLS '00 Proceedings of the Technology of Object-Oriented Languages and Systems (TOOLS 34'00)
Implementing Reusable Object-Oriented Components
ICSR '98 Proceedings of the 5th International Conference on Software Reuse
A semi-automated approach for analyzing, separating, and modeling of concerns in evolving systems
OOPSLA '05 Companion to the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
When refactoring acts like modularity: keeping options open with persistent condition checking
Proceedings of the 2nd Workshop on Refactoring Tools
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Hi-index | 0.00 |
Parnas' seminal 1972 paper, "On the Criteria To Be Used in Decomposing Systems into Modules," identified simplifying change as a critical criterion for modularizing software. Successful designs are those in which a change can be accommodated by modifying a single module. There is a tacit assumption in most of the literature that once a change has been limited to a single module, the cost of making the change is essentially inconsequential. But modules have complexity of their own and are frequently large. Thus, making a change can be expensive, even if limited to a single module.We present a method of decomposing modules into smaller components for the purpose of supporting change. Although similar to the approach of modularizing programs described by Parnas, our approach is specific to decomposing modules. It is not intended to replace traditional high level modularization but rather to augment it with a second level of modularization where the standard of information hiding can be relaxed. The goal of the method is to make modules easier to change by decomposing them around smaller design decisions---ideally encoding only one design choice per submodule component.In this paper we show how submodule components can be used to address the issue of change. We also demonstrate how the ability to address change with submodule components is, to a large extent, independent of the design level modularization. Moreover, we show that, at least in some cases, by using submodule components the choice of high level modularization can itself be changed without having to rewrite large amounts of code.A method of implementation is presented using inheritance, parameterization, and static binding in a way that minimizes implementation dependencies between components. The method supports fine grained decomposition with flexible composability and almost no runtime overhead.