Home > Store

Framework Process Patterns: Lessons Learned Developing Application Frameworks

Register your product to gain access to bonus material or receive a coupon.

Framework Process Patterns: Lessons Learned Developing Application Frameworks

Book

  • Sorry, this book is no longer in print.
Not for Sale

Description

  • Copyright 2002
  • Dimensions: 7-3/8x9-1/4
  • Pages: 256
  • Edition: 1st
  • Book
  • ISBN-10: 0-201-73132-0
  • ISBN-13: 978-0-201-73132-3

Frameworks represent a rapidly growing field within object-oriented programming and development. A framework is a set of cooperating classes that make up a reusable design that addresses a specific application domain. Yet, for all of their value, frameworks are widely misunderstood.

In this book, two framework development experts borrow from their extensive real-world experience to introduce a successful patterns approach to framework development. The authors reveal proven techniques and useful solutions for successful framework development. Through this book, you can enhance your skills and learn to make the transition from object-oriented programmer to framework developer.

Framework Process Patterns presents working patterns that apply to all phases of the framework development process, from requirements and analysis through documentation. It focuses on the essential issue of what constitutes an appropriate domain, and how to strike the delicate balance between reusability and content. This book also examines the human side of framework development, with advice on effective communication and optimal team organization. Many of these patterns have broad applicability not just to framework development, but to object-oriented and component-based development in general.

You will read about important topics, including:

  • Applying patterns to framework development
  • Maintaining consistency throughout the framework
  • Reducing refinement iterations
  • Distinguishing implementations from requirements
  • Balancing capabilities versus keeping the framework focused
  • Decomposing the development of a framework
  • Using a framework by mapping to it
  • Providing documentation that addresses various framework audiences
  • Promoting domain-technical cross-team communication
  • Establishing framework consistency by defining “Consistency Czar”
  • A single case study runs throughout the book to illustrate the application of principles and techniques. The book also includes two valuable appendices. The first looks at the relationship between frameworks and components, and the second documents the IBM SanFrancisco framework development process.

    Written for proficient object-oriented programmers who want to learn more about this important field or want to validate their own real-life experiences in the trenches of object-oriented development, Framework Process Patterns will bring you far along the path toward fully understanding frameworks and maximizing their potential.



    0201731320B01282002

    Sample Content

    Online Sample Chapters

    Framework Process Patterns: A Case Study

    Introduction to Developing Object-Oriented Frameworks

    Downloadable Sample Chapter

    Click below for Sample Chapter(s) related to this title:
    Sample Chapter 1
    Sample Chapter 2

    Table of Contents



    Preface.

    Why Listen to Us?

    How to Read This Book.

    Acknowledgments.



    1. Introduction.

    What Is a Framework?

    Framework Artifacts.

    Developing Frameworks.

    Using Frameworks.

    The Framework Process Patterns.



    2. Case Study.

    The Clothing Management Domain.

    Overview.

    Selecting Clothing.

    Cleaning Clothing.

    Reparing Clothing.

    Purchasing Clothing.



    3. The Development Process.

    Alles in Ordnung.

    Follow a Methodical Development Process.

    Innocent Questions.

    Connecting Domain and Technical Experts.

    Divide and Conquer.

    Making the Framework Consumable.

    Consistency Is King.

    Maintain Consistency throughout the Framework.

    Iterate, Iterate, Iterate.

    Three Iterations to Validate.

    Exposing It All.

    A Framework's Customer Is Its Partner.
    4. Requirements.

    It Depends.

    Identifying Customization.

    Tor's Second Cousin.

    How Extreme Is Too Extreme?

    What, Not How.

    Implementations Masquerading as Requirements.

    The Stupid Test.

    Include Obvious Domain Capabilities While Keeping the Framework Focused.
    5. Analysis.

    Eating the Elephant (One Byte at a Time).

    Decomposing the Problem.

    Something Is Better Than Nothing.

    Document What You Know When You Know It.

    Where's Mr. Spock When You Need Him?

    Domain-Technical Cross-Team Communication.
    6. Design.

    Pass the Buck.

    Knowing When a Framework Shouldn't Do Something.

    Missed It by That Much.

    Developing and Applying Patterns.

    That's the Way the Cookie Crumbles.

    Patterns Can Be Mini-Frameworks.

    It's Still OO to Me.

    Frameworks Aren't Exempt from Good and Bad Object-Oriented Practices.
    7. Documentation.

    Souvenirs.

    Keeping Just Enough to Write Documentation Later.

    Give 'Em What They Want.

    Different Framework Audiences Have Different Needs.
    8. Social Aspects.

    There Is No “I” in Team.

    The Importance of Team Dynamics.

    The Great Communicator.

    Translating between Domain and Technical Terminology and Concepts.

    Consistency Czar.

    Making Sure Consistency Happens.
    9. Framework Use.

    Just Learn It.

    Using Frameworks Requires Up-Front Education.

    Map Early, Map Often.

    Use Frameworks by Mapping.

    Color Inside the Lines.

    Change Only What You Need to Change.
    10. Conclusion.Appendix A. Frameworks and Components.

    What Is a Component?

    Fine- and Coarse-Grained Components.

    Building Coarse-Grained Components.

    Appendix B. The IBM SanFrancisco Frameworks Development Process.

    Process Flow.

    Process Artifacts.

    Process Participants.

    Process Step Details.

    Bibliography.Index. 0201731320T04172002

    Preface

    What does it take to create object-oriented application frameworks? How do you create something that provides the core of an application and does it in a way that can be used to build many applications? Object-oriented programming skills are a great start, but they just aren’t enough to create a successful framework. So what else do you need?

    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 an existing 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.

    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:

  • 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.

    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



    0201731320P01072002

    Index

    Click below to download the Index file related to this title:
    Index

  • Updates

    Submit Errata

    More Information

    Unlimited one-month access with your purchase
    Free Safari Membership