Software Generators, Architectures, and Reuse

Don Batory
Department of Computer Sciences
University of Texas
Austin, Texas 78712

Vision

Next generation of software engineering tools will include component-based, domain-specific software generators. These generators are among the pinnacle of results on software reuse: they are implementations of domain models (or reference architectures) that define how software systems of a domain can be assembled by composing components from reuse libraries. The primary goal of generators is to maximize the value of reuse: i.e., eliminate the mundane aspects of software construction and to permit the expenditure of proportionally more effort on the critical parts of target systems.

Audience for Tutorial

This tutorial is aimed at researchers and practitioners who are faced with the problem of building families of software systems economically, and/or who are interested in assembling customized and evolvable software systems from reuse libraries. It assumes rudimentary knowledge of OO concepts, but no experience with the tutorial's subject.

The Tutorial

GenVoca is scalable model of software generation that has been distilled from independently conceived and implemented generators for the domains of databases, compilers, communication protocols, file systems, data structures, and avionics [2-4,6]. This tutorial presents practical concepts and lessons learned from these projects so that others may benefit from them and avoid their pitfalls and reinvention. Summaries of all lectures are given below.

• Introduction. The central concepts of GenVoca are presented æ virtual machines; libraries (called realms) of parameterized [7], plug-compatible, interchangeable and interoperable components; modeling the architecture of hierarchical software systems as named composition of components (called type equations); symmetric components (components that export and import the same virtual machine); scalability of domain models; performance and productivity advantages of generators.
• An Example. We model and analyze a simple domain using GenVoca concepts. We show how realms of individual components are defined and how compositions are expressed. We explain and illustrate the property of scalability (i.e., how GenVoca generators can synthesize exponentially large families of systems by combining small numbers of components [3]). We will also explain GenVoca models of software domains are implementation independent - this allows analysts to create models of domains independently of how they will be ultimately implemented. This (turns out to be) a significant conceptual advance in domain modeling.
• Subjective Interfaces. A central goal of domain modeling is to create a design for a family of systems. However, not all systems export the same interface; there will always be different (but regular) variations among different systems. How is it possible to generate software systems with customized interfaces from components that have standardized interfaces? In this lecture, we explain how this apparent contradiction is resolved by a fundamental concept of software design called subjectivity [8]. We review both OO implementations of subjectivity (i.e., those that rely on a sophisticated use of inheritance and parameterization) and non-OO implementations.
• Domain Modeling. This lecture reviews the domain model of ADAGE (avionics software) and the approach taken to develop it. This was the first attempt to apply GenVoca ideas on domain where the domain modeler was not a domain expert. Experiences with other domain modeling activities are discussed and the “things to do” and “things not to do” are highlighted.
• Design Rule Checking. A fundamental problem in software composition technologies is determining whether or not a given composition of components is consistent. Not having an automatic means of validating consistency would require the impossible: generator users would have to debug generated code. In GenVoca, this is the situation that not all syntactically correct compositions are semantically correct. Design rule checking (DRC) of compositions is the counterpart to semantic checking in compilers; domain-specific constraints per component are checked to reveal inconsistencies. We present efficient algorithms that validate type equations automatically [5]. GenVoca DRC algorithms rely on a powerful and practical form of shallow consistency checking similar to that used in validating architectural constraints in Perry's Inscape Environment [10].
• Architectural Styles. A fundamental concept in component design is the separation of component computations from the protocols that enable components to interchange their results. This idea is called architectural styles [12]. In this lecture, we examine how architectural styles can be expressed within the GenVoca framework, and how architectural styles impacts domain modeling and generator implementations.

The tutorial notes come with an extensive bibliography.

The Instructor

Don Batory holds the David Bruton Jr Centennial Professorship Chair in the Department of Computer Sciences at the University of Texas at Austin and is an industry consultant on component-based software generators. He was a member of the ACM Software Systems Award Committee, where in 1993 he was the Committee Chairman. He also was an Associate Editor of ACM Transactions on Database Systems from 1986 to 1992, and an Associate Editor of IEEE Database Engineering from 1981 to 1984. Dr. Batory was the Program Chairman for the 3rd International Conference on Software Reuse (1994) and is the Program Chairman for the 1999 International Workshop on Software Reuse. His experience with the GenVoca model and software system generators is extensive. He and his students built Genesis (1985-1990), the first software system generator for database systems [1]. He co-authored the GenVoca paper [2] with Dr. Sean O’Malley. He and his students built P1, P2, and P3 (1991-1997), the first scalable generators for data structures [3]. He was a member of ADAGE, a project to develop a domain-specific software architecture environment for generating avionics software. His role was to apply GenVoca concepts to create a reference architecture for avionics software [4].

References

1. D. Batory, “Concepts for a DBMS Synthesizer”, in Domain Analysis and Software Systems Modeling, R. Prieto-Diaz and G. Arango, Editors, IEEE Computer Society Press, 1991.
2. D. Batory and S. O’Malley, “The Design and Implementation of Hierarchical Software Systems with Reusable Components”, ACM Transactions on Software Engineering and Methodology, October 1992.
3. D. Batory, V. Singhal, M. Sirkin, and J. Thomas, “Scalable Software Libraries”, ACM SIGSOFT, December 1993.
4. D. Batory, L. Coglianese, M. Goodwin, and S. Shafer, “Creating Reference Architectures: An Example from Avionics”, 1995 Symposium on Software Reuse (Seattle, Washington).
5. D. Batory and B. Geraci, “Validating Compositions and Subjectivity and GenVoca Generators”, IEEE Transactions on Software Engineering, February 1997.
6. D. Batory, B. Lofaso, and Y. Smaragdakis, “JTS: A Tool Suite for Building GenVoca Generators”, 5th International Conference on Software Reuse, June 1998..
7. J.A. Goguen, “Reusing and Interconnecting Software Components”, IEEE Computer, February 1986.
8. R. Harrison and H. Ossher, “Subject-Oriented Programming (A Critique of Pure Objects)”, OOPSLA 1993, 411-428.
9. N. Hutchinson and L. Peterson, “The x-kernel: an Architecture for Implementing Network Protocols”, IEEE Trans. Software Engineering, January 1991.
10. D. Perry, “The Logic of Propagation in The Inscape Environment”, ACM SIGSOFT 1989.
11. D. Garlan and M. Shaw, “An Introduction to Software Architecture”, in Advances in Software Engineering and Knowledge Engineering, Volume I, World Scientific Publishing Company, 1993.