Abstract
Systematic discovery and exploitation of commonality across related software systems is a fundamental technical requirement for achieving successful software reuse. By examining a class/family of related systems and the commonality underlying those systems, it is possible to obtain a set of reference models, i.e., software architectures and components needed for implementing applications in the class. FORM (Feature-;Oriented Reuse Method) supports development of such reusable architectures and components (through a process called the “domain engineering”) and development of applications using the domain artifacts produced from the domain engineering. FORM starts with an analysis of commonality among applications in a particular domain in terms of services, operating environments, domain technologies, and implementation techniques. The model constructed during the analysis is called a “feature” model, and it captures commonality as an AND/OR graph, where AND nodes indicate mandatory features and OR nodes indicate alternative features selectable for different applications. Then, this model is used to define parameterized reference architectures and appropriate reusable components instantiatable during application development. Architectures are defined from three different viewpoints (subsystem, process, and module) and have intimate association with the features. The subsystem architecture is used to package service features and allocate them to different computers in a distributed environment. Each subsystem is further decomposed into processes considering the operating environment features. Modules are defined based on the features on domain technology and implementation techniques. These architecture models that represent an architecture at different levels of abstraction are derived from the feature hierarchy captured in the feature model. Modules serve as basis for creating reusable components, and their specification defines how they are integrated into the application (e.g., as-;is integration of pre-;coded component, instantiation of parameterized templates, and filling-;in skeletal codes). Our experiences have shown that for the electronic bulletin board and the private branch exchange (PBX) domains, “features” make up for a common domain language and the main communication medium among application users and developers. Thus, the feature model well represents a “decision space” of software development, and is a good starting point for identifying candidate reusable components.
This is a preview of subscription content, log in via an institution to check access.
Similar content being viewed by others
References
Aho, A.V. and N. Griffeth (1995), “Feature Interaction in the Global Information Infrastructure,” In Proceedings of the Third ACM SIGSOFT Symposium on the Foundations of Software Engineering, ACM SIGSOFT, Washington, DC, pp. 2–5.
Batory, D., L. Coglianese, M. Goodwin and S. Shafer (1995), “Creating Reference Architectures: An Example from Avionics,” In Proceedings of the ACM-SIGSOFT Symposium on Software Reusability, ACM SIGSOFT, Washington, DC, pp. 27–37.
Biggerstaff, T.J. (1989), “Design Recovery for Maintenance and Reuse,” IEEE Software 22, 7, 36–49.
Buschmann, T., R. Meunier, H. Rohnert, P. Sommerlad and M. Stal (1996), Pattern-Oriented Software Architecture: A System of Patterns, Wiley, Reading, MA.
Bryant, A.D. (1994), Creating Successful Bulletin Board Systems, Addison-Wesley, Reading, MA.
Cameron, E.J. and H. Velthuuijsen (1993), “Feature Interactions in Telecommunications Systems,” IEEE Communications Magazine 31, 18–23.
Fekete, A. (1993), “Formal Models of Communication Services: A Case Study,” IEEE Computer 26, 8, 37–47.
Floch, J. (1995), “Supporting Evolution and Maintenance by Using a Flexible Automatic Code Generator,” In Proceedings of the 17th International Conference of Software Engineering, IEEE Computer Society Press, Los Alamitos, CA, pp. 211–219.
Gamma, E., R. Helm, R. Johnson and J. Vlissides (1995), Design Patterns: Elements of Reusable Object-Oriented Design, Addison-Wesley, Reading, MA.
Gomaa, H. (1993), Software Design Methods for Concurrent and Real-Time Systems, Addison-Wesley, Reading, MA.
Gomaa, H., L. Kerschberg, V. Sugumaran, C. Bosch and I. Tarakoli (1994), “A Prototype Domain Modeling Environment for Reusable Software Architectures,” In Proceedings of the Third International Conference on Software Reuse: Advances in Software Reusability, IEEE Computer Society Press, Los Alamitos, CA, pp. 74–83.
Griffeth, N.D. and Y. Lin (1993), “Extending Telecommunications Systems: The Feature-Interaction Problem,” IEEE Computer 26, 8, 14–18.
Kang, K.C., S.G. Cohen, J.A. Hess, W.E. Novak and A.S. Peterson (1990), “Feature-Oriented Domain Analysis (FODA) Feasibility Study,” Technical Report CMU/SEI-90-TR-21, Software Engineering Institute, Carnegie Mellon University, Pittsburgh, PA.
Kang, K.C., J.J. Lee, S.J. Kim, K.J. Kim and E.S. Shin (1997), “Feature-Oriented Engineering of PBX Software for Adaptability and Reusability,” Submitted to IEEE Transactions on Software Engineering.
Luckham, D.C., J.J. Kenny, L.M. Augustin, J. Vera, D. Bryan and W. Mann (1995), “Specification and Analysis of System Architecture Using Rapide,” IEEE Transactions on Software Engineering, Special Issue on Software Architecture 21, 4, 336–335.
McKenny, P.E. (1996), “Selecting Locking Primitives for Parallel Programming,” Communications of ACM 39, 10, 75–82.
Mettala, E. and M.H. Graham (1992), “The Domain-Specific Software Architecture Program,” Technical Report CMU/SEI-92-SR-9, Software Engineering Institute, Carnegie Mellon University, Pittsburgh, PA.
Moriconi, M., X. Qian and R.A. Reimenschneider (1995), “Correct Architecture Refinement,” IEEE Transactions on Software Engineering 21, 4, 356–372.
Neighbors, J. (1984), “The Draco Approach to Constructing Software from Reusable Components,” IEEE Transactions on Software Engineering 10, 5, 564–574.
Palmer, J.D. and Y. Liang (1992), “Indexing and Clustering of Software Requirements Specifications,” Information and Decision Technologies 18, 4, 283–299.
Perry, D.E. and A.L. Wolf (1992), “Foundations for the Study of Software Architecture,” ACM SIGSOFT Software Engineering Notes 17, 4, 40–52.
Shaw, M. and D. Garlan (1996), Software Architecture: Perspectives on an Emerging Discipline, Prentice-Hall, Saddle River, NJ.
Sloane, A.M. and J. Holdswirth (1996), “Beyond Traditional Program Slicing,” ACM SIGSOFT Software Engineering Notes 21, 3, 180–186.
Stephen H.E. (1990), “An Approach for Constructing Reusable Software Components in Ada,” IDA Paper P-2378, Institute for Defense Analyses, Alexandria, VA.
Tracz, W. (1993), “LILEANNA: A Parameterized Programming Language,” In Proceedings of the Second International Workshop on Software Reuse, IEEE Computer Society Press, Los Alamitos, CA, pp. 66– 78.
Wolfe, D. (1994), The BBS Construction Kit, Wiley, New York, NY.
Zave, P. (1993), “Feature Interactions and Formal Specifications in Telecommunications,” IEEE Computer 26, 8, 20–28.
Author information
Authors and Affiliations
Rights and permissions
About this article
Cite this article
Kang, K.C., Kim, S., Lee, J. et al. FORM: A feature-;oriented reuse method with domain-;specific reference architectures. Annals of Software Engineering 5, 143–168 (1998). https://doi.org/10.1023/A:1018980625587
Issue Date:
DOI: https://doi.org/10.1023/A:1018980625587