- Shopping Bag ( 0 items )
Other sellers (Paperback)
-
All (8) from $2.00
-
New (2) from $45.00
-
Used (6) from $2.00
More About This Textbook
Overview
Editorial Reviews
From The Critics
Two framework developers introduce a patterns approach to framework development, demonstrating useful techniques and solutions for successful framework development. Suitable for the proficient object-oriented programmer. Includes two valuable appendices: a section on frameworks and components and the IBM San Francisco frameworks development process. Annotation c. Book News, Inc., Portland, ORProduct Details
Related Subjects
Table of Contents
Preface
Many of you underwent a change when you went from procedural programming to object-oriented programming. Until you made that change, you could write in Java (or C++), but you weren't actively doing object-oriented programming (except by accident). You gained experience, through books and mentoring (and making mistakes) which transformed you. You internalized a set of patterns for object-oriented programming. Patterns that helped you use proper inheritance, patterns that made your designs truly object-oriented, and patterns that helped you form effective development teams. Becoming a framework developer involves a similar transition. It isn't as large a transition, but it is still a transition.
What makes frameworks unique? Frameworks are a balancing act between providing reusable content (e.g. pre-built business objects and processes for business applications) and flexibility (allowing that content to be customized to do exactly what the framework user wants). This is a very delicate balancing act. When too much flexibility is provided, the framework splinters into small confederations of business objects with low-level processes—very much like a class library. On the other hand, if too much content is provided, we risk complicating customization to the point where no one will be able to use it—very much like trying to use anexisting application to write another. Learning how to effectively find this balance point is what the transition to becoming a framework developer is about.
To help you make this transition, this book contains the distillation of what we learned as we became framework developers. We've distilled key aspects of our experience into patterns that you can immediately apply to your work. Patterns that we believe are not only valuable to anyone working with frameworks (developing, using or evaluating), but also to other software developers. Framework development tested and intensified what we learned during our transition to object-oriented developers, thus we feel that object-oriented developers will benefit. Also, with the development of more and more customizable applications, components and Web Services, the patterns about teams of technical (non-domain) and non-technical (domain) experts working together to develop software are becoming increasingly applicable.
This book isn't about object-oriented development or how to program in a particular object oriented language. It doesn't describe arcane algorithms, radically new development processes, or arguments for a new way to model object-oriented designs. Instead, we've captured (as patterns) situations that we've encountered (and that typically occur) during normal object-oriented framework development. We cover the range of development activities from initial requirements gathering to documenting the framework. We also spend some time on the human side of development—how to deal with the interactions between all the different types of people who need to work together to make a software development project successful. Finally we briefly look at using a framework to develop an application.
You will get the most value from this book if you have experience in object-oriented development. If you are new to object-oriented programming, you will still find this book valuable—it will expose you to a number of issues you will encounter in the future. This book will be useful to framework developers and framework users. Framework users will benefit not only from patterns specific to using the framework, but also by knowing what should have gone into the development of the framework. Managers of object-oriented development projects will find this book useful because it points out some of the potential pitfalls and significant issues your development teams will have to deal with throughout the software development process.
What are these patterns? The “Tor's 2nd cousin” pattern , for example, is named after one of the domain experts working on the IBM SanFrancisco frameworks (named Tor). Tor had the ability to identify cases where the framework needed flexibility that no one else had thought of. We attributed these revelations to his fictitious (and crazy) 2nd cousin. In many cases, these scenarios represented requirements that were, simply put, too flexible. In other words, only a miniscule percentage of the applications built using the framework would ever need to use the framework in the way Tor described. As development leaders in the project, we had to make hard decisions whenever these cases came up: should we include support for such flexible requirements in the framework or not? The Tor's 2nd cousin pattern captures making this tradeoff between flexibility and complexity. Flexibility that is needed by some small portion of the framework's target audience but that requires additional complexity in the framework should be avoided. This rule provided a way to look at these situations without anyone taking offense. Asking if a requirement came from “Tor's 2nd cousin” didn't imply that the requirement was invalid or that the person who suggested the requirement was stupid or out of line, it merely caused us to make sure that we considered the complexity/flexibility tradeoff. By giving this rule a humorous name, we were also able to defuse tensions that might have otherwise arisen as people debated the requirement. We have found that humor, when properly applied, is extremely effective in building a team and reducing tension; especially in the stressful environment that results from developing software under great time pressures. For these reasons most of these patterns have humorous names in addition to their more descriptive names. Tor's 2nd cousin is also known as 'How Extreme is Too Extreme?'
Why patterns? Each pattern in this book is documented in a consistent manner so that you can easily examine the pattern and its applicability, and determine whether it can be applied to your particular situation or possibly used as a starting point for defining your own solution. Each pattern has the following sections:
Why listen to us?
Like many of you, we started off as procedural programmers. We were taught object-oriented techniques in the classroom and then tempered our skills in the furnace of experience. We both worked on building portions of an object-oriented operating system in C++. These pieces were part of the project that moved the AS/400 from a CISC to a RISC processor base in the early 1990's. This project involved changing or replacing over a million lines of code. Most of the organization was new to object-oriented development, so we didn't concentrate just on our own designs and code, instead the team was very open and helped one another by discussing and reviewing each other's designs and code. By the time we completed the CISC to RISC conversion, we were both very experienced object-oriented developers. This is the starting point for the experiences captured in this book.Where did we go from there? We were both brought onto the IBM SanFrancisco project to develop distributed object-oriented business application frameworks in Java. The goal was to produce something that would provide application developers the core of their applications. In other words, the part everyone does; the ante to play the game. The framework would allow application developers to spend more time making their application unique, adding those things that differentiate it from its competitors, rather than simply keeping up by providing what everyone provides. The framework would allow application developers to customize framework elements for their unique requirements.
The SanFrancisco frameworks were delivered as a number of layers. At the bottom were the more traditional technically-oriented frameworks that supported things such as persistence and distributed objects (much of which is now provided by Java's EJBs ). Built on these technical frameworks were the business application frameworks. These frameworks, instead of capturing reusable technical solutions, captured reusable business content—business objects and business processes. The frameworks were further divided into those applicable across most, if not all, domains and those targeted as specific domains, such as warehouse management or accounting. Although we were involved with development of all of the layers, our main focus was the business application frameworks that captured business content.Part I discusses the patterns that apply across the entire framework development process.
Part II discusses the patterns related to identifying and capturing requirements.
Part III continues with the development process by looking at patterns from the analysis phase.
Part IV covers the design phase patterns.
Part V discusses the patterns associated with documentation. Extensive documentation is crucial when developing frameworks.
Part VI discusses the social aspects of framework (and general object-oriented software) development, including patterns unique to domain and technical expertise residing in separate people.
Part VII discusses patterns related to using the framework.
The SanFrancisco development team chose to use object-oriented techniques because of all the standard reasons: effective isolation and decomposition of complexity, improved maintainability, and partitioning of development effort into self-contained chunks, among others 1. One reason that was especially appealing was that object-oriented techniques allow responsibilities to be encapsulated into objects. Thus we could make the scope of change in any one part of the framework limited and understandable, something key to a framework which expects changes for customization. Java was chosen because it would allow the application the most flexibility on which platform to run on.
When we were done the IBM SanFrancisco frameworks had over 1000 business-oriented classes and nearly 1,000,000 lines of Java code, making the IBM SanFrancisco frameworks the largest commercial object oriented business application framework ever completed and sold.
What do lots of classes and code have to do with listening to us? Directly, not much. What they show is that we have had to use framework techniques to solve a lot of problems. We didn't simply write one small framework and declare a pattern because we saw something once—or thought it might be a pattern. We identified these patterns because we saw them over and over again. They were identified, refined and used by the entire team—a team of both technical and domain experts. Finally, numerous software developers have validated these patterns by building flexible applications, both for broad resale and for very specific business needs on top of the IBM SanFrancisco frameworks.
How to read this book
All readers should read the Introduction and Case Study chapters. The Introduction provides the underlying context of the patterns by describing what a framework is, how it is developed and how it is used. It shows how the patterns fit together and gives you a jumping off point to go to those patterns that are of interest to you. The Case Study chapter provides a common domain and vocabulary from which we can present the problems that lead to the patterns and the approaches to solving them.Once you've read the Introduction and Case Study chapters the remaining chapters can be read in any order. Managers, or developers trying to get an overview of the patterns should consider reading the Intent, Problem, Solution and Applicability sections for all of the chapters. The remaining sections can then be read when going back and reading the chapter in detail, possibly focusing first on those patterns that seem to be the most applicable.
Related patterns have been collected together into parts which identify where their primary application. These parts are:
Two appendices are included. Appendix A describes the complementary relationship between components and frameworks. Appendix B describes the development process used to develop the business application frameworks as part of the IBM SanFrancisco project.
Acknowledgments
These rules were not something that we came up with on our own. They are the result of the team effort that went into developing the IBM SanFrancisco frameworks. Each member of the team contributed in some way to the experience that went into these rules. We want to thank each and every one of the team members—you were one of the best teams we've ever gotten to work for.1Object-Oriented Analysis and Design with Applications by Grady Booch, Benjamin/Cummings, 1994, ISBN 0805353402