• Develop an enterprise framework.
• Utilize single and multiple frameworks.
• Document an enterprise framework.
• Integrate multiple frameworks on different levels of abstraction.

Company executives, like project managers, object-oriented business owners, presidents, and CEOs, will benefit from learning what has been proven to work for others who have developed, utilized, and integrated frameworks in various problem domains. The results described here should save company executives many weeks of experimentation and prevent loss of resources. Company executives will also find discussions related to framework economics, practical tips, and experiences in dealing with OO application frameworks. These are accompanied by assessments of application frameworks.

Software developers (software engineers, programmers, designers), engineering staffs (system engineers), and technologists will benefit from the insights that are presented here regarding OO application framework architecture, model representation, domain analysis, integration, deployment, administration, and documentation.

Software process groups can use the framework development, utilization, integration processes, and case studies as a guide to avoid false starts and pitfalls.

Customers and end users are the most important part of any application framework, in particular, an enterprise framework. The belief or attitude that the insights of the customers or users are not the most important information used on a development project will doom software to failure. In addition, end users will gain a sound understanding of application frameworks and why these frameworks are assets to an organization.

Software methodologists will learn what has worked and what has not worked when developing and adapting frameworks in various problem domains. This insight will allow software methodologists to focus on improving problem areas in existing techniques and help them avoid these problems when constructing new techniques and utilizing frameworks.

Graduate courses on framework technology or advanced software engineering will also benefit by using this book. Graduate courses on software engineering, object-oriented software engineering, object-oriented distributed computing, and design patterns can use this book as a supplemental text for students, as can courses on system engineering and advanced courses on enterprise developments. Prerequisites include basic knowledge of computing terms and concepts and basic knowledge of software engineering concepts and techniques. This book contains several pedagogical aids:

• More than 178 figures are used to illustrate concepts and models.
• Review questions and problem sets are included at the end of each chapter. These are self-study aids designed to test the student's ability to apply the concepts and techniques covered in each chapter.
• Projects suitable for teams are also included at the end of most chapters.
• A glossary at the end of the book defines all new terms used in the book.
• An authors index at the end of the book lists each author's affiliation, country, primary e-mail address, URL, chapters contributed, and a brief biography.
• An instructor guide is also available. The guide describes ways to use this book in different courses, provides a course outline, and supplies an answer key for most of the problems at the end of each chapter.

Book Organization

Building Application Frameworks consists of 8 parts, 26 chapters, and 8 sidebars.

Part 1: Framework Overview

Chapter 1, " Application Frameworks," provides a brief technical and managerial overview of the state of application frameworks.. It defines the essential and common terminology related to the OO application frameworks and answers common questions about frameworks like, "What is a framework?," "What are the differences between application frameworks and class libraries, repositories, design patterns, and components?," "What are the strengths and weaknesses of application frameworks?," and "When should OO application frameworks be used?" It also illustrates different framework categorizations, like blackbox and whitebox frameworks. Chapter one defines applications frameworks, provides several classifications of application frameworks, describes the characteristics of application frameworks, discusses pros and cons, and contrasts frameworks with other reuse approaches.

Chapter 2, "Frameworks & Patterns: Architectural Abstractions," elaborates on the term "software architecture" by further developing the concept of architectural abstractions. The authors contribute a conceptual model of architectural abstractions, an analysis of current pattern approaches, current framework understanding, and a new perspective on both patterns and frameworks as examples of architectural abstractions. The technical innovation in Chapter 2 is a characterization of the concept of architectural abstraction in terms of structural characteristics, functionality, abstraction, and reuse.

Chapter 3, "Framework Problems and Experiences," discusses problems with application frameworks based on the authors' experiences. The problems are organized into five categories: framework development, learning, usage, composition, and maintenance. For each category, the authors present the most relevant problems and experiences. The purpose of Chapter 3 is to help software engineers avoid the described problems and to suggest topics for future research.

Sidebar 1, "Enterprise Frameworks," introduces object-oriented enterprise frameworks (OOEFs). A new way of developing, deploying, extending and administering enterprise systems is emerging. These systems are either developed as in-house solutions by organizations not satisfied with commercially available options for managing the enterprise, or were procured from a small but growing population of enterprise framework vendors. OOEFs should not be confused with middleware and standards for distributed objects (that is, CORBA, and DCOM). Interoperability represents but a single characteristic of an OOEF. Furthermore, OOEF components may be implemented as Vertical CORBAfacilities, but this definition alone does not satisfy the requirements of an OOEF. OOEFs are an emerging discipline of developers and development teams that address reuse in a radical way. OOEFs allow distributed applications to be deployed rapidly with very little coding because applications leverage the framework and the enduring business processes and themes encoded into the framework itself.

Part 2: Framework Perspectives

Chapter 4, "SIMULA Frameworks: The Early Experience," describes some of the earliest object-oriented application frameworks on record. These were written in the 1960's and 70's using Simula, the language that invented objects classes, inheritance, and virtual binding. Although many of the concepts introduced by Simula have now been integrated into the current generation of object-oriented languages, many useful features of Simula were never widely discussed and are still overlooked. The chapter starts out with a brief overview of the language, its history and its principal features including coroutine sequencing. Then, it presents a sequence of frameworks that allows Simula, a general purpose programming language, to describe and program increasingly complex parallel systems. Although Simula frameworks have been developed in other areas, it is in the area of parallel programming that Simula, initially developed for simulation, has the most to offer. Parallel programming is also of particular interest for today's multi-tasking environments.

First, Chapter 4 describes the two standard frameworks furnished with every Simula system that provide list processing and discrete event simulation. Then, the chapter introduces other frameworks developed independently of the Simula team, which extend the ability to simulate parallel systems. These include GPSSS for queuing models and the UMxx series for the modeling of operating systems. Finally, the chapter shows that Simula's elegant notation is not limited to simulated parallelism. Several frameworks that extend Simula's process scheduling to real-time are presented. The chapter then explores another unusual aspect of Simula. Inheritance between objects is a key concept in the use of frameworks but Simula extends the concept by allowing a program to inherit from a class. The chapter also describes some early Simula inspired research that illustrated the usefulness for frameworks of allowing inheritance between methods. Finally, the chapter concludes with some lessons that can be drawn from these pioneering efforts.

Chapter 5, "Visual Builders: Framework Design Issues," discusses guidelines for constructing classes and components to be used by a visual builder. Early object-oriented class libraries were designed to deliver as much functionality as possible. Design standards evolved to meet the needs of programmers who wrote every line of application code themselves. Today, an increasing number of application programmers use visual builders (and, to a lesser extent, wizards) to generate much (but rarely all) code. Visually generated code also makes use of class libraries. In this new environment, however, programmers tie together classes by using an interface, with a minimum of handwritten code. Good framework design must now address the needs of visual programmers as well as those of direct coders. This chapter describes design issues where hard coding and visual development requirements diverge.

Chapter 6, "Usability and Framework Design," discusses general guidelines for framework usability. User interface usability has received much attention by the computer science community, but little formal attention has been paid to the usability of application programming interfaces (APIs) as in class libraries and frameworks. Programmer productivity is claimed as a key benefit of frameworks, but productivity hinges on how easy they are to learn and use. The usability guidelines have been arrived at over time during development of commercial class libraries and frameworks.

Sidebar 2, "Viewpoints and Frameworks," describes inter- and intra- viewpoint representations. A key consideration is that multiple viewpoints must present the same system consistently. The sidebar describes a viewpoint in terms of an object-oriented model because of the rich constructs it can provide. The concepts associated with viewpoints are still evolving. For example, the Unified Modeling Language (UML) uses intra-viewpoints, while the Open Distributed Processing (ODP) standard uses inter-viewpoints.

Part 3: Frameworks and Domain Analysis

Chapter 7, "Deriving Frameworks from Domain Knowledge, " discusses how to drive application frameworks from domain knowledge. Although a considerable number of successful frameworks have been developed during the last decade, designing a high-quality framework is still a difficult task. Generally, it is assumed that finding the correct abstractions is very hard, and therefore a successful framework can only be developed through a number of iterative (software) development efforts. Accordingly, existing framework development practices span a considerable amount of refinement time, and it is worthwhile to shorten this effort. To this end, Chapter 7 aims to define explicit models for the knowledge domains that are related to a framework. The absence of such models may be the main reason for the current extensive refinement efforts. The applicability of the approach is illustrated by means of three pilot projects. This chapter indicates that some aspects of domain knowledge could not be directly modeled in terms of object-oriented concepts. It describes an approach, the pilot projects, the experienced problems, and the adopted solutions for realizing the frameworks, and concludes with lessons learned.

Chapter 8, "Harvesting Design," discusses the harvesting process of application framework design. The design of application frameworks employs both problem and solution domain analysis. By analyzing existing solutions, one can harvest design and code that can be refined for reuse in new frameworks. The steps of the harvesting process include identification of existing solution candidates, analysis of their domains for similarities and variations, and framework implementation. Chapter 8 describes how this harvesting process was used to evaluate several solutions from different industry domains, and to produce a general purpose framework for application task management.

Sidebar 3, "Frameworks and Domain Models: Two Sides of the Same Coin, " discusses the relationship between frameworks, domain abstraction, and architecture models. Frameworks and domains models are closely related. The behavior and usability of frameworks depend on their capability to fit different requirements. Frameworks originate from the analysis of domains and are designed to support the development of new applications. A domain model is a general representation for many applications in a problem domain; applications potential exists, but application have yet to be developed. The goal of frameworks and of domain models is (a) to describe commonalty and variability and (b) to support management of the different parts in similar products from the same domain. Framework development and domain analysis & engineering (DA&E) have the same economical justification: they exploit the economies of scope arising from the reuse of the assets in the domain. Sidebar 3 outlines how DA&E can positively support the production of frameworks, and focuses on Sherlock, an object-oriented DA&E technique targeted to the development of frameworks.

Part 4: Framework Development Concepts

Chapter 9, "Reusing Hooks," discusses a hooks approach for reusing and utilizing object-oriented application frameworks. Object-oriented frameworks can be complex. Often, considerable time is needed to understand the framework, including not only what the framework does, but also how to use it. Techniques for documenting the design of a framework already exist, but less work has been done on documenting how to use the framework. This chapter discusses the notion of hooks as a means of representing knowledge about the places in a framework that can be adapted by application developers to produce an application from the framework and have applied the concept to the SEAF (Size Engineering Application Framework) project. By describing the hooks, implicit knowledge about how to reuse the framework is made explicit and open to study, refinement, or use. Having this knowledge available can make frameworks easier to reuse, since developers need not spend the time deriving the knowledge themselves. With hooks, a template is provided to describe the hooks and to capture all of the relevant knowledge in a form that provides guidance to application developers. This chapter discusses the model of hooks as a means of capturing knowledge about how to reuse the framework, reports the authors' experience with hooks in the SEAF project, and gives some initial assessment of the notion of hooks.

Chapter 10, "A Framework Recipe," describes a proven technique that software architects can use in creating the foundation of application architecture. . The technique is presented as a recipe that includes seven individual patterns as the raw ingredients and a series of steps or guidelines for combining the patterns to create a flexible application framework. Architects can use the recipe to gain insight into a subset of the challenges of building robust technology solutions. These architectures are crucial to the successful adoption of new technologies that are ultimately used to support the ongoing business of an organization. The main contributions of this work are a self-contained pattern system that builds upon the growing catalog of design patterns available to software developers and which is open to extension and customization. The technical innovations of this work are that framework-based development is encouraged as a means to resolve the various issues surrounding application architecture design. Both inheritance-based and delegation-based framework approaches are provided in the recipe's solutions in addition to design patterns approach to describing frameworks--work continues in that vein.

Chapter 11, "Capturing Hypermedia Functionality," presents lessons learned and experience in the design and implementation of an object-oriented application framework (OO-Navigator) that allows you to add hypermedia functionality to an object-oriented application. First, Chapter 11 discusses what it means to combine navigation with more conventional computations. Next, the authors present the architecture of the OO-Navigator framework. This chapter briefly describes the use of the framework by showing how their components are instantiated and plugged into application objects. The framework's architecture is then exposed in terms of design patterns. Finally, the authors discuss ongoing work.

Chapter 12, "Understanding Frameworks," describes how to understand application framework behavior and defines a trace-based approach for specifying the behavior of the framework. When designing a framework F, the designer abstracts away certain key methods of certain key classes of the framework leaving them as virtual functions (in C++ terminology). One of the most important contributions that F makes to the final application built on F is the flow of control implemented in the non-virtual functions of F; this relieves the application builder from having to worry about this important and difficult issue. An application builder who builds a complete application A using F refines the abstract base classes of F by providing specific bodies for the virtual functions, thus implementing specific behaviors the term "behavioral refinement" characterizes this type of refinement. Chapter 12 addresses several important questions: "How do we understand the behavior--specifically the flow-of-control behavior--implemented by the framework code?", "How do we understand the behavior implemented by the method bodies defined in the application code?",, and "How do we combine these to obtain an understanding of the behavior of the entire application?"

It also describes a trace-based approach for specifying the behavior of the framework, in particular the control flow. The particular refinement that an application builder implements is captured in an appropriate refined specification of the respective virtual functions of F. This chapter then shows how this refined specification can be combined with the specification of the framework to arrive at the behavior of the entire application, and illustrates the approach using a simple diagram editor framework.

Chapter 13, "Capturing Framework Requirements," describes how to capture application framework requirements. Application frameworks have become a widely used foundation for system development. Although refactoring existing class structures and architectures is the preferred technique for developing a framework, numerous business pressures have resulted in the need to identify and capture requirements for a framework in the beginning of the development process. This chapter describes use case assortment, a framework requirements capture and tracing technique. The technique refactors a use case model that represents requirements for an application. The refactored use cases then provide framework requirements that allow the application to be developed from a framework. The technique is illustrated by examples taken from the telephony domain.

Chapter 14, "Managing Class Dependencies," classifies and describes techniques for managing class dependencies in frameworks. Class dependencies occur when different hot spots within a framework aren't independent of each other, but the flexibility offered by one hot spot reduces the flexibility offered by others. A classification is presented that introduces four categories of techniques for managing class dependencies: closely coupled classes, consistent object creation, data-driven classes, and meta-level configuration. Several techniques from each category are presented, and their advantages and disadvantages are discussed. A framework for interactive and animated presentations on the Web is presented as a case study.

Sidebar 4, "Formal Design and Performance Evaluation," describes an example for developing and evaluating application frameworks based on a formal architecture description language.

Part 5: Framework Development Approaches

Chapter 15, "Frameworks Design by Systematic Generalization," discusses framework design by systematic generalization.. Framework design by systematic generalization overcomes the inherent complexity of framework design by clearly separating the design of a class model for a fixed application from the framework domain from the introduction of variability in generalization steps and by separating the analysis and specification of a hot spot from the high level design of a hot spot subsystem and its implementation by a generalizing transformations.

A generalization cycle analyzes and specifies the characteristics of a variable aspect in a hot spot specification, determines the high level design of the hot spot subsystem, which usually follows a design pattern that provides the specific kind of variability and flexibility required, and transforms the class model by introducing the hot spot subsystem.

Chapter 16, "Hot-Spot-Driven Development," describes hot-spot-driven framework development. Most excellent object-oriented frameworks are still the products of a more or less chaotic development process, typically carried out in the realm of research-like settings. Overall, flexibility has to be injected into a framework in appropriate doses. Framework adaptation takes place at points of predefined refinement called hot spots. As the quality of a framework depends directly on the appropriateness of hot spots, hot spot identification has to become an explicit activity in the framework development process. Means for documenting and communicating hot spots between domain experts and software engineers becomes crucial. This contribution first discusses the few essential framework construction principles, that is, how to keep object-oriented architectures flexible for adaptations. The chapter introduces hot spot cards as means to capture flexibility requirements, and illustrate how to apply them in combination with the essential framework construction principles. The presented heuristics form a hot-spot-driven framework design process which leads to a more systematic framework construction with fewer (re)design iterations.

Chapter 17, "Structuring Large Application Frameworks," introduces concepts and techniques for structuring large application frameworks. Frameworks are key assets in large-scale object-oriented software development. They promise increased productivity, and provide shorter development times and higher application quality. To achieve these goals, frameworks should be designed so that they can evolve, be easily reused, adapted, and configured. Drawing on experience in large-scale industrial banking projects, this chapter describes concepts and techniques for domain partitioning, framework layering and framework construction. In particular, Chapter 17 discusses how domain aspects relate to framework structure, how frameworks are layered to accommodate domain needs, and how the resulting framework layers are integrated without tight coupling.

Sidebar 5, "Framelets: Small is Beautiful," introduces the notion of framelets, which are essentially small frameworks. Framelets can be easily understood and modified. As framelets are not aimed at complex application domains, they can also be assembled without the problems associated with the combination of large frameworks. Framelets are architectural building blocks that allow the integration of framework technology into legacy applications. Furthermore, framelets might form a suitable means for structuring software architectures.

Chapter 18, "Understanding Macroscopic Behavior Patterns with Use Case Maps," describes how to understand macroscopic behavior patterns with use case maps . Object-oriented frameworks provide a powerful construction technique for software, but understanding the behavior of applications constructed from them is well known to be difficult, for a number of reasons. 1) The first class representation of the framework in code centers around construction; system structure and behavior are only visible in a second class way, in widely scattered details. 2) The desired system view is not a concrete thing, but an abstraction. 3) The use of design patterns, a common practice in frameworks, may obscure the system view by making inter-component interactions more indirect than they would otherwise be. 4) The use of combinations of design patterns obscures the system view because pattern combination is not yet a well defined subject. 5) Both the desired system view and design patterns are abstractions, so gaining system understanding requires combining multiple abstractions, for frameworks that make serious use of design patterns. 6) Although framework class organizations are fixed, systems constructed from frameworks are self modifying while they are running, and self modifying software is notoriously difficult to understand. 7) Specific applications are visible only in framework customization details. Chapter 18 illustrates by example how a general technique called use case mapsinvented by the author for describing complex systems of any kind-can help to alleviate these difficulties. To indicate the range of applicability, the examples are drawn from frameworks in very different application domains: HotDraw for GUIs and ACE for communications. The authors hope to raise the visibility of the UCM approach of use case maps in the framework community to help alleviate the aforementioned problems, but not to prove UCMs solve them or to provide a cookbook for solving them.

Chapter 19, "Composing Modeling Frameworks in Catalysis," discusses how the Catalysis method generalizes the concept of frameworks to object modeling and specification activities, permitting construction of specification and design models by composition. This work enables specification and modeling activities to be much more constructive, where models are generated from appropriate generic specification models based on particular aspects of the problem at hand.

Sidebar 6 briefly presents insights for software development strategy selection and some of the highlights of a relatively new approach called Enduring Business Themes (EBTs) that works well for systems that must be highly change-centric. The EBT approach leads to software systems that can accommodate unexpected change with a minimal ripple effect. It avoids the use of successive refinement, so there is an abrupt discontinuity between requirements and the ensuing models. The approach also accommodates different developer skill levels more effectively than most traditional solutions.

Part 6: Framework Testing and Integration

Chapter 20 discusses framework integration problems, causes, and solutions. Reuse of software has been one of the main goals of software engineering for decades. With the emergence of the object-oriented paradigm, an important enabling technology for reuse of larger components became available and resulted in the definition of object-oriented frameworks. Experiences with frameworks have shown that frameworks indeed provide considerable reuse in framework-based application development. However, whereas framework-based application development initially included a single framework, increasingly multiple frameworks are used in application development. Chapter 20 provides a significant collection of common framework composition problems encountered in application development together with an analytical discussion of the underlying causes for the problems. Based on the composition problems and the identified primary causes, this chapter describes and analyzes existing solution approaches and their limitations. The composition problems discussed are 1) composition of framework control, 2) composition with legacy components, 3) framework gap, 4) overlap of framework entities and 5) composition of entity functionality. The primary causes for these composition problems are related to 1) the cohesion between classes inside each framework, 2) the domain coverage of the frameworks, 3) the design intentions of the framework designers and 4) the potential lack of access to the source code of the frameworks. The identified problems and their causes are, up to some extent, addressed by existing solutions, such as the adapter design pattern, wrapping or mediating software, but these solutions generally have limitations and either do not solve the problem completely or require considerable implementation efforts.

Sidebar 7, "Built-in Test Reuse," describes a method for incorporating the reusable BITs into object-oriented application frameworks.. The reuse approaches to the BITs in OOAF development have been analyzed. The BIT method has extended the reusability of OOAFs from code to tests. By the BIT approach, highly testable and test reusable OOAFs can be developed on the same platform of the conventional OO software. The BIT method is a natural advance and supplementary to conventional OO technology for OOAF development. A wide range of applications of the BIT method have been found in OOAF development, testing, maintenance, and reengineering.

Part 7: Framework Documentation

Chapter 21, "Documenting Frameworks," focuses on the documentation of frameworks rather than on framework development. This chapter shows that many approaches to documenting frameworks have been tried, and amongst these are several that have proven effective in reducing the learning curve and presents guidelines for documenting a framework in order to facilitate the reuse of the framework by application developers.

Chapter 22, "Empowering Framework Users," describes a set of guidelines for how to train new users unfamiliar with a framework's architecture so they are able to understand the underlying concepts, and are able to use and adapt the framework.

Chapter 23, "Describing and Using Frameworks," shows how to develop a representation of frameworks that satisfies the following goals: 1) A description of inter-object behavior that supports both formal verification and understanding, 2) Abstraction and generalization, 3) Language-independence, 4) An easy extraction of the descriptions from actual code, and more importantly, 5) Support for reuse related tasks such as searchability, description of usage, incremental extension, and «operationalization»/realization. The main contributions of this work are a model that attempts to address these often conflicting goals, and a set of tools to support the reuse the lifecycle of frameworks, from specification to integration.

Sidebar 8,"Documenting Frameworks: Solitaire is Not Alone," describes the process of creating new solitaire games using a framework consists of implementing a predictable collection of classes as subclasses of appropriate framework classes. Frameworks are amenable to documentation by examples. This sidebar shows how to design and document a Solitaire framework from which many diverse games can be quickly built.

Part 8: Framework Management and Economics

Chapter 24, "Strategic Analysis of Application Framework Investments," covers strategic analysis of application framework investments. The goal of this chapter is to assist managers in the strategic planning process for investments in application framework technology. The principal contribution of the chapter is the presentation of a value based approach to investment planning that encourages the elaboration and evaluation of strategic options within a disciplined strategic and economic framework. The authors described strategic options with respect to their potential for improvement of the organization's competitive position and its ability to participate in economically profitable markets. Both the operational and strategic sources of value in organizational reuse capability are exploited through active management of technical and market risk. The innovations in this chapter include the introduction of concepts and techniques from option pricing theory and their application to the evaluation of strategic framework investment scenarios such as new market entry, market re-positioning, and investment timing.

Chapter 25, "Evaluating Structural & Functional Stability," describes a method for evaluating the structural and functional characteristics of framework architectures as they evolve with the development of new versions. Using this method, developers and managers can objectively assess the relative extent-of-changes in the framework architectural characteristics and then make inferences about the framework's architecture stability. In this approach, the structural and functional characteristics of framework architectures are evaluated using a suite of object-oriented design metrics. Metrics' values for successive versions of frameworks are computed and compared to determine the extent-of-change in architectural characteristics between versions. This method has been applied to all publicly released versions of the Microsoft Foundation Classes (MFC) and Borland Object Windows (OWL) application frameworks to evaluate changes in characteristics and compute the extent-of-change between versions. The evaluations show that the most significant causes of architectural changes between versions are the reworks in collaborations between classes, assignment of responsibilities to classes, and the addition of new classes to enhance the features/capabilities of the framework systems. A key attribute of the method is that it can be easily modified to include different suites of architectural characteristics and metrics for evaluation, thus providing a practical framework for architecture stability assessment that is adaptable to different domains and environments.

Sidebar 9, "Framework Maintenance: Vendor ViewPoint," describes the expectation mismatch between vendors and customers There are two major components of this mismatch: the views and the needs of the customer do not coincide with those of the vendor's.

Chapter 26, "Future Trends," discusses the future directions with research in component-based framework technology

Other Literature

Many object-oriented books discuss primarily programming issues or a certain object-oriented technology from a single perspective. Each of the existing object-oriented books claims that its content (approach) is the ultimate approach. These texts, of course, avoid showing the limited side of its content (approach). This book provides the balance needed to show that OOEFs are an important consideration for organizations and describes many keys of the hidden cost factors of the illustrated object-oriented application frameworks. This book is compatible with other books on object-oriented technology in general, and we feel that this book provides added value to a broad community of computer and software professionals involved in the management and development of software projects as well as company executives, project managers, engineering staff, technologists. Any firms which market enterprise systems commercially, or who are considering expanding into the enterprise systems marketplace will gain important insights from this book.

Supplemental Materials

Further information on individual framework projects can be found at the contributors' URLs included in the authors index. Updates, news, question-and-answer sessions, and comments to the authors can be found at www.cse.unl.edu/~fayad and the Wiley Web page at www.wiley.com/compbooks/frameworks.

The Wiley Web page for this book includes the following:

• Detailed table of contents
• Chapter abstracts
• Complete chapter references
• Miscellaneous listings of theme issues, special-interest groups, conferences, and so on
• Extended index of authors
• Annotated references
• Solutions for instructors
• A question-and-answer session
FAQ: Application and enterprise frameworks, component-based developments, design patterns, and more

---

WCP Home Page

[ Framework Foundations ]

[ Implementing Frameworks ]

[ Domain-Specific Frameworks ]

Copyright © 1999 John Wiley & Sons, Inc. Wiley Computer Publishing