Design Patterns Explained: A New Perspective on Object-Oriented Design [NOOK Book]

Overview

"One of the great things about the book is the way the authors explain concepts very simply using analogies rather than programming examples–this has been very inspiring for a product I'm working on: an audio-only introduction to OOP and software development."

–Bruce Eckel

"...I would expect that readers with a basic understanding of object-oriented programming and design would find this book useful, before approaching design patterns completely. Design Patterns Explained complements the existing design patterns ...

See more details below
Design Patterns Explained: A New Perspective on Object-Oriented Design

Available on NOOK devices and apps  
  • NOOK Devices
  • NOOK HD/HD+ Tablet
  • NOOK
  • NOOK Color
  • NOOK Tablet
  • Tablet/Phone
  • NOOK for Windows 8 Tablet
  • NOOK for iOS
  • NOOK for Android
  • NOOK Kids for iPad
  • PC/Mac
  • NOOK for Windows 8
  • NOOK for PC
  • NOOK for Mac
  • NOOK Study

Want a NOOK? Explore Now

NOOK Book (eBook)
$27.49
BN.com price
(Save 42%)$47.99 List Price

Overview

"One of the great things about the book is the way the authors explain concepts very simply using analogies rather than programming examples–this has been very inspiring for a product I'm working on: an audio-only introduction to OOP and software development."

–Bruce Eckel

"...I would expect that readers with a basic understanding of object-oriented programming and design would find this book useful, before approaching design patterns completely. Design Patterns Explained complements the existing design patterns texts and may perform a very useful role, fitting between introductory texts such as UML Distilled and the more advanced patterns books."

–James Noble

Leverage the quality and productivity benefits of patterns–without the complexity! Design Patterns Explained, Second Edition is the field's simplest, clearest, most practical introduction to patterns. Using dozens of updated Java examples, it shows programmers and architects exactly how to use patterns to design, develop, and deliver software far more effectively.

You'll start with a complete overview of the fundamental principles of patterns, and the role of object-oriented analysis and design in contemporary software development. Then, using easy-to-understand sample code, Alan Shalloway and James Trott illuminate dozens of today's most useful patterns: their underlying concepts, advantages, tradeoffs, implementation techniques, and pitfalls to avoid. Many patterns are accompanied by UML diagrams.

Building on their best-selling First Edition, Shalloway and Trott have thoroughly updated this book to reflect new software design trends, patterns, and implementation techniques. Reflecting extensive reader feedback, they have deepened and clarified coverage throughout, and reorganized content for even greater ease of understanding. New and revamped coverage in this edition includes

  • Better ways to start "thinking in patterns"
  • How design patterns can facilitate agile development using eXtreme Programming and other methods
  • How to use commonality and variability analysis to design application architectures
  • The key role of testing into a patterns-driven development process
  • How to use factories to instantiate and manage objects more effectively
  • The Object-Pool Pattern–a new pattern not identified by the "Gang of Four"
  • New study/practice questions at the end of every chapter

Gentle yet thorough, this book assumes no patterns experience whatsoever. It's the ideal "first book" on patterns, and a perfect complement to Gamma's classic Design Patterns. If you're a programmer or architect who wants the clearest possible understanding of design patterns–or if you've struggled to make them work for you–read this book.

Read More Show Less

What People Are Saying

James Noble
"...I would expect that readers with a basic understanding of object-oriented programming and design would find this book useful, before approaching design patterns completely. Design Patterns Explained complements the existing design patterns texts and may perform a very useful role, fitting between introductory texts such as UML Distilled and the more advanced patterns books."
Read More Show Less

Product Details

  • ISBN-13: 9780321630049
  • Publisher: Pearson Education
  • Publication date: 10/26/2004
  • Series: Software Patterns Series
  • Sold by: Barnes & Noble
  • Format: eBook
  • Edition number: 2
  • Pages: 480
  • Sales rank: 672,659
  • File size: 6 MB

Meet the Author

Alan Shalloway is founder, CEO, and principal consultant of Net Objectives, an object-oriented consulting and training organization. An object-oriented consultant and software developer for over 20 years, he is a frequent speaker at leading development conferences, including SD Expo, Java One, OOP, and OOPSLA. He is a certified Scrum master. He is co-author of An Introduction to XML and its Family of Technologies. Shalloway holds a master's degree in computer science from MIT.

James R. Trott currently works as a senior consultant for a large financial institution in the Pacific Northwest. He has used object-oriented and pattern-based analysis techniques throughout his 20-year career in knowledge management and knowledge engineering. He holds a master of science in applied mathematics, an MBA, and a master of arts in intercultural studies.


Read More Show Less

Read an Excerpt

Chapter 8: Expanding Our Horizons

Overview

In this chapter In previous chapters, I discussed three fundamental concepts of object-oriented design: objects, encapsulation, and abstract classes. How a designer views these concepts is important. The traditional ways are simply too limiting. In this chapter I step back and reflect on topics discussed earlier in the book. My intent is to describe a new way of seeing object-oriented design, which comes from the perspective that design patterns create.

In this chapter,

  • I compare and contrast the traditional way of looking at objects—as a bundle of data and methods—with the new way—as things with responsibilities.
  • I compare and contrast the traditional way of looking at encap-sulation— as hiding data—with the new way—as the ability to hide anything. Especially important is to see that encapsulation can be used to contain variation in behavior.
  • I compare and contrast the traditional way of using inherit-ance— for specialization and reuse—with the new way—as a method of classifying objects.
  • The new viewpoints allow for containing variation of behaviors in objects.
  • I show how the conceptual, specification, and implementation perspectives relate to an abstract class and its derived classes.
Acknowledgment

Perhaps this new perspective is not all that original. I believe that this perspective is one that many developers of the design patterns held when they developed what ended up being called a pattern. Certainly, it is a perspective that is consistent with the writings of Christopher Alexander, Jim Coplien, and the Gang of Four.

While it may not be original, it has also not been expressed in quite the way I do in this chapter and in this book. I have had to distill this way of looking at patterns from the way design patterns behave and how they have been described by others.

When I call it a new perspective, what I mean is that it is most likely a new way for most developers to view object orientation. It was certainly new to me when I was learning design patterns for the first time.

Objects: the Traditional View and the New View

The traditional view: data with methods

The traditional view of objects is that they are data with methods. One of my teachers called them "smart data." It is just a step up from a database. This view comes from looking at objects from an implementation perspective.

The new view: things with responsibilities

While this definition is accurate, as explained in Chapter 1, "The Object-Oriented Paradigm," it is based on the implementation per-spective. A more useful definition is one based on the conceptual perspective—an object is an entity that has responsibilities. These responsibilities give the object its behavior. Sometimes, I also think of an object as an entity that has specific behavior.

This is a better definition because it helps to focus on what the objects are supposed to do, not simply on how to implement them. This enables me to build the software in two steps:

1. Make a preliminary design without worrying about all of the details involved.

2. Implement the design achieved.

Ultimately, this perspective allows for better object selection and definition (in a sense, the main point of design anyway). Object definition is more flexible; by focusing on what an object does, inheritance allows us to use different, specific behaviors when needed. A focus on implementation may achieve this, but flexibility typically comes at a higher price.

It is easier to think in terms of responsibilities because that helps to define the object's public interface. If an object has a responsibility, there must be some way to ask it to perform its responsibility. How-ever, it does not imply anything about what is inside the object. The information for which the object is responsible may not even be inside the object itself.

For example, suppose I have a Shape object and its responsibilities are

  • To know where it is located
  • To be able to draw itself on a display
  • To be able to remove itself from a display
These responsibilities imply that a particular set of method calls must exist:
  • getLocation( ... )
  • drawShape( ... )
  • unDrawShape( ... )
There is no implication about what is inside of Shape. I only care that Shape is responsible for its own behaviors. It may have attributes inside it or it may have methods that calculate or even refer to other objects. Thus, Shape might contain attributes about its location or it might refer to another database object to get its location. This gives you the flexibility you need to meet your mod-eling objectives.

Interestingly, you will find that focusing on motivation rather than on implementation is a recurring theme in design patterns. Look at objects this way. Make it your basic viewpoint for objects. If you do, you will have superior designs.

Encapsulation: the Traditional View and the New View

My object-oriented umbrella

In my classes on pattern-oriented design, I often ask my students, "Who has heard encapsulation defined as ‘data hiding'?" Almost everyone raises his or her hand.

Then I proceed to tell a story about my umbrella. Keep in mind that I live in Seattle, which has a reputation for being wetter than it is, but is still a pretty wet place in the fall, winter, and spring. Here, umbrellas and hooded coats are personal friends!

Let me tell you about my great umbrella. It is large enough to get into! In fact, three or four other people can get in it with me. While we are in it, staying out of the rain, I can move it from one place to another. It has a stereo system to keep me entertained while I stay dry. Amazingly enough, it can also condition the air to make it warmer or colder. It is one cool umbrella.

My umbrella is convenient. It sits there waiting for me. It has wheels on it so that I do not have to carry it around. I don't even have to push it because it can propel itself. Sometimes, I will open the top of my umbrella to let in the sun. (Why I am using my umbrella when it is sunny outside is beyond me!)

In Seattle, there are hundreds of thousands of these umbrellas in all kinds of colors.

Most people call them cars.

But I think of mine as an umbrella because an umbrella is some-thing you use to keep out of the rain. Many times, while I am wait-ing outside for someone to meet me, I sit in my "umbrella" to stay dry!

Definitions can be limitations

Of course, a car isn't really an umbrella. Yes, you can use it to say out of the rain, but that is too limited a view of a car. In the same way, encapsulation isn't just for hiding data. That is too limited a view of encapsulation. To think of it that way constrains my mind when I design.

How to think about encapsulation

Encapsulation should be thought of as "any kind of hiding." In other words, it can hide data. But it can also hide implementations, derived classes, or any number of things. Consider the diagram shown in Fig-ure 8-1. You might recollect this diagram from Chapter 7, "The Adapter Pattern...."

Read More Show Less

Table of Contents

I. AN INTRODUCTION TO OBJECT-ORIENTED SOFTWARE DEVELOPMENT.

1. The Object-Oriented Paradigm.

Overview.

Before the Object-Oriented Paradigm: Functional Decomposition.

The Problem of Requirements.

Dealing with Changes: Using Functional Decomposition.

Dealing with Changing Requirements.

The Object-Oriented Paradigm.

Object-Oriented Programming in Action.

Special Object Methods.

Summary.

Review Questions.

2. The UML-The Unified Modeling Language.

Overview.

What Is the UML?

Why Use the UML?

The Class Diagram.

Interaction Diagrams.

Summary.

Review Questions.

II. THE LIMITATIONS OF TRADITIONAL OBJECT-ORIENTED DESIGN.

3. A Problem That Cries Out for Flexible Code.

Overview.

Extracting Information from a CAD/CAM System.

Understand the Vocabulary.

Describe the Problem.

The Essential Challenges and Approaches.

Summary.

Review Questions.

4. A Standard Object-Oriented Solution.

Overview.

Solving with Special Cases.

Summary.

Review Questions.

III. DESIGN PATTERNS.

5. An Introduction to Design Patterns.

Overview.

Design Patterns Arose from Architecture and Anthropology.

Moving from Architectural to Software Design Patterns.

Why Study Design Patterns?

Other Advantages of Studying Design Patterns.

Summary.

Review Questions.

6. The Facade Pattern.

Overview.

Introducing the Facade Pattern.

Learning the Facade Pattern.

Field Notes: The Facade Pattern.

Relating the Facade Pattern to the CAD/CAM Problem.

Summary.

Review Questions.

7. The Adapter Pattern.

Overview.

Introducing the Adapter Pattern.

Learning the Adapter Pattern.

Field Notes: The Adapter Pattern.

Relating the Adapter Pattern to the CAD/CAM Problem.

Summary.

Review Questions.

8. Expanding Our Horizons.

Overview.

Objects: The Traditional View and the New View.

Encapsulation: The Traditional View and the New View.

Find What Is Varying and Encapsulate It.

Commonality and Variability Analysis and Abstract Classes.

The Qualities of Agile Coding.

Summary.

Review Questions.

9. The Strategy Pattern.

Overview.

An Approach to Handling New Requirements.

The International E-Commerce System Case Study: Initial Requirements.

Handling New Requirements.

The Strategy Pattern.

Field Notes: Using the Strategy Pattern.

Summary.

Review Questions.

10. The Bridge Pattern.

Overview.

Introducing the Bridge Pattern.

Learning the Bridge Pattern: An Example.

An Observation About Using Design Patterns.

Learning the Bridge Pattern: Deriving It.

The Bridge Pattern in Retrospect.

Field Notes: Using the Bridge Pattern.

Summary.

Review Questions.

11. The Abstract Factory Pattern.

Overview.

Introducing the Abstract Factory Pattern.

Learning the Abstract Factory Pattern: An Example.

Learning the Abstract Factory Pattern: Implementing It.

Field Notes: The Abstract Factory Pattern.

Relating the Abstract Factory Pattern to the CAD/CAM Problem.

Summary.

Review Questions.

IV. PUTTING IT ALL TOGETHER: THINKING IN PATTERNS.

12. How Do Experts Design?

Overview.

Building by Adding Distinctions.

Summary.

Review Questions.

13. Solving the CAD/CAM Problem with Patterns.

Overview.

Review of the CAD/CAM Problem.

Thinking in Patterns.

Thinking in Patterns: Step 1.

Thinking in Patterns: Step 2a.

Thinking in Patterns: Step 2b.

Thinking in Patterns: Step 2c.

Thinking in Patterns: Steps 2a and 2b Repeated (Facade).

Thinking in Patterns: Steps 2a and 2b Repeated (Adapter).

Thinking in Patterns: Steps 2a and 2b Repeated (Abstract Factory).

Thinking in Patterns: Step 3.

Comparison with the Previous Solution.

Summary.

Review Questions.

V. TOWARD A NEW PARADIGM OF DESIGN.

14. The Principles and Strategies of Design Patterns.

Overview.

The Open-Closed Principle.

The Principle of Designing from Context.

The Principle of Encapsulating Variation.

Abstract Classes vs. Interfaces.

The Principle of Healthy Skepticism.

Summary.

Review Questions.

15. Commonality and Variability Analysis.

Overview.

Commonality and Variability Analysis and Application Design.

Solving the CAD/CAM Problem with CVA.

Summary.

Review Questions.

16. The Analysis Matrix.

Overview.

In the Real World: Variations.

The International E-Commerce System Case Study: Handling Variation.

Field Notes.

Summary.

Review Questions.

17. The Decorator Pattern.

Overview.

A Little More Detail.

The Decorator Pattern.

Applying the Decorator Pattern to the Case Study.

Another Example: Input/Output.

Field Notes: Using the Decorator Pattern.

The Essence of the Decorator Pattern.

Summary.

Review Questions.

VI. OTHER VALUES OF PATTERNS.

18. The Observer Pattern.

Overview.

Categories of Patterns.

More Requirements for the International E-Commerce Case Study.

The Observer Pattern.

Applying the Observer to the Case Study.

Field Notes: Using the Observer Pattern.

Summary.

Review Questions.

19. The Template Method Pattern.

Overview.

More Requirements for the International E-Commerce Case Study.

The Template Method Pattern.

Applying the Template Method to the International E-Commerce Case Study.

Using the Template Method Pattern to Reduce Redundancy.

Field Notes: Using the Template Method Pattern.

Summary.

Review Questions.

VII. FACTORIES.

20. Lessons from Design Patterns: Factories.

Overview.

Factories.

The Universal Context Revisited.

Factories Follow Our Guidelines.

Limiting the Vectors of Change.

Another Way to Think About It.

Different Roles of Factories.

Field Notes.

Summary.

Review Questions.

Overview.

21. The Singleton Pattern and the Double-Checked Locking Pattern.

Introducing the Singleton Pattern.

Applying the Singleton Pattern to the Case Study.

A Variant: The Double-Checked Locking Pattern.

Reflections.

Field Notes: Using the Singleton and Double-Checked Locking Patterns.

Summary.

Review Questions.

22. The Object Pool Pattern.

Overview.

A Problem Requiring the Management of Objects.

The Object Pool Pattern.

Observation: Factories Can Do Much More Than Instantiation.

Summary.

Review Questions.

23. The Factory Method Pattern.

Overview.

More Requirements for the Case Study.

The Factory Method Pattern.

Factory Method Pattern and Object-Oriented Languages.

Field Notes: Using the Factory Method Pattern.

Summary.

Review Questions.

24. Summary of Factories.

Overview.

Steps in the Software Process.

Parallels in Factories and XP Practices.

Scaling Systems.

VIII. ENDINGS AND BEGINNINGS.

25. Design Patterns Reviewed: A Summation and a Beginning.

Overview.

A Summary of Object-Oriented Principles.

How Design Patterns Encapsulate Implementations.

Commonality and Variability Analysis and Design Patterns.

Decomposing a Problem Domain into Responsibilities.

Patterns and Contextual Design.

Relationships Within a Pattern.

Design Patterns and Agile Coding Practices.

Field Notes.

Summary.

Review Questions.

26. Bibliography.

Design Patterns Explained: The Web Site Companion.

Recommended Reading.

Recommended Reading for Java Programmers.

Recommended Reading for C++ Programmers.

Recommended Reading for COBOL Programmers.

Recommended Reading on eXtreme Programming.

Recommended Reading on General Programming.

Personal Favorites.

Index

Read More Show Less

Preface

Design patterns and object-oriented programming. They hold such promise to make your life as a software designer and developer easier. Their terminology is bandied about every day in the technical and even the popular press. But it can be hard to learn them, to become proficient with them, to understand what is really going on.

Perhaps you have been using an object-oriented or object-based language for years. Have you learned that the true power of objects is not inheritance but is in "encapsulating behaviors"? Perhaps you are curious about design patterns and have found the literature a bit too esoteric and high-falutin. If so, this book is for you. It is based on years of teaching this material to software developers, both experienced and new to object orientation.

It is based upon the belief—and our experience—that once you understand the basic principles and motivations that underlie these concepts, why they are doing what they do, your learning curve will be incredibly shorter. And in our discussion of design patterns, you will understand the true mindset of object orientation, which is a necessity before you can become proficient.

As you read this book, you will gain a solid understanding of the ten most essential design patterns. You will learn that design pat-terns do not exist on their own, but are supposed to work in concert with other design patterns to help you create more robust applications. You will gain enough of a foundation that you will be able to read the design pattern literature, if you want to, and possibly discover patterns on your own.

Most importantly, you will be better equipped to create flexibleand complete software that is easier to maintain.

From Object Orientation to Patterns to True Object Orientation

In many ways, this book is a retelling of my personal experience learning design patterns. Prior to studying design patterns, I considered myself to be reasonably expert in object-oriented analysis and design. My track record had included several fairly impressive designs and implementations in many industries. I knew C and was beginning to learn Java. The objects in my code were well-formed and tightly encapsulated. I could design excellent data abstractions for inheritance hierarchies. I thought I knew object-orientation.

Now, looking back, I see that I really did not understand the full capabilities of object-oriented design, even though I was doing things the way the experts advised. It wasn't until I began to learn design patterns that my object-oriented design abilities expanded and deepened. Knowing design patterns has made me a better designer, even when I don't use these patterns directly.

I began studying design patterns in 1996. I was a C???oriented design mentor at a large aerospace company in the north-west. Several people asked me to lead a design pattern study group. That's where I met my co-author, Jim Trott. In the study group, several interesting things happened. First, I grew fascinated with design patterns. I loved being able to compare my designs with the designs of others who had more experience than I had. I discovered that I was not taking full advantage of designing to interfaces and that I didn't always concern myself with seeing if I could have an object use another object without knowing the used object's type. I noticed that beginners to object-oriented design—those who would normally be deemed as learning design patterns too early—were benefiting as much from the study group as the experts were. The patterns presented examples of excellent object-oriented designs and illustrated basic object-oriented principles, which helped to mature their designs more quickly. By the end of the study sessions, I was convinced that design patterns were the greatest thing to happen to software design since the invention of object-oriented design.

However, when I looked at my work at the time, I saw that I was not incorporating any design patterns into my code.

I just figured I didn't know enough design patterns yet and needed to learn more. At the time, I only knew about six of them. Then I had what could be called an epiphany. I was working on a project as a mentor in object-oriented design and was asked to create a high-level design for the project. The leader of the project was extremely sharp, but was fairly new to object-oriented design.

The problem itself wasn't that difficult, but it required a great deal of attention to make sure the code was going to be easy to maintain. Literally, after about two minutes of looking at the problem, I had developed a design based on my normal approach of data abstraction. Unfortunately, it was very clear this was not going to be a good design. Data abstraction alone had failed me. I had to find something better.

Two hours later, after applying every design technique I knew, I was no better off. My design was essentially the same. What was most frustrating was that I knew there was a better design. I just couldn't see it. Ironically, I also knew of four design patterns that "lived" in my problem but I couldn't see how to use them. Here I was a supposed expert in object-oriented design baffled by a simple problem!

Feeling very frustrated, I took a break and started walking down the hall to clear my head, telling myself I would not think of the problem for at least 10 minutes. Well, 30 seconds later, I was thinking about it again! But I had gotten an insight that changed my view of design patterns: rather than using patterns as individual items, I should use the design patterns together.

Patterns are supposed to be sewn together to solve a problem.

I had heard this before, but hadn't really understood it. Because patterns in software have been introduced as design patterns, I had always labored under the assumption that they had mostly to do with design. My thoughts were that in the design world, the pat-terns came as pretty much well-formed relationships between classes. Then, I read Christopher Alexander's amazing book, The Timeless Way of Building. I learned that patterns existed at all levels—analysis, design, and implementation. Alexander discusses using patterns to help in the understanding of the problem domain (even in describing it), not just using them to create the design after the problem domain is understood.

My mistake had been in trying to create the classes in my problem domain and then stitch them together to make a final system, a process which Alexander calls a particularly bad idea. I had never asked if I had the right classes because they just seemed so right, so obvious; they were the classes that immediately came to mind as I started my analysis, the "nouns" in the description of the system that we had been taught to look for. But I had struggled trying to piece them together.

When I stepped back and used design patterns and Alexander's approach to guide me in the creation of my classes, a far superior solution unfolded in only a matter of minutes. It was a good design and we put it into production. I was excited—excited to have designed a good solution and excited about the power of design patterns. It was then that I started incorporating design patterns into my development work and my teaching. I began to discover that programmers who were new to object-oriented design could learn design patterns, and in doing so, develop a basic set of object-oriented design skills. It was true for me and it was true for the students that I was teaching.

Imagine my surprise! The design pattern books I had been reading and the design pattern experts I had been talking to were saying that you really needed to have a good grounding in object-oriented design before embarking on a study of design patterns. Nevertheless, I saw, with my own eyes, that students who learned object-oriented design concurrently with design patterns learned object-oriented design faster than those just studying object-oriented design. They even seemed to learn design patterns at almost the same rate as experienced object-oriented practitioners.

I began to use design patterns as a basis for my teaching. I began to call my classes Pattern Oriented Design: Design Patterns from Analysis to Implementation.

I wanted my students to understand these patterns and began to discover that using an exploratory approach was the best way to foster this understanding. For instance, I found that it was better to present the Bridge pattern by presenting a problem and then have my students try to design a solution to the problem using a few guiding principles and strategies that I had found were present in most of the patterns. In their exploration, the students discovered the solution—called the Bridge pattern—and remembered it.

In any event, I found that these guiding principles and strategies could be used to "derive" several of the design patterns. By "derive a design pattern," I mean that if I looked at a problem that I knew could be solved by a design pattern, I could use the guiding principles and strategies to come up with the solution that is expressed in the pattern. I made it clear to my students that we weren't really coming up with design patterns this way. Instead, I was just illustrating one possible thought process that the people who came up with the original solutions, those that were eventually classified as design patterns, might have used.

My abilities to explain these few, but powerful, principles and strategies improved. As they did, I found that it became more useful to explain an increasing number of the Gang of Four patterns. In fact, I use these principles and strategies to explain 12 of the 14 patterns I discuss in my design patterns course.

I found that I was using these principles in my own designs both with and without patterns. This didn't surprise me. If using these strategies resulted in a design equivalent to a design pattern when I knew the pattern was present, that meant they were giving me a way to derive excellent designs (since patterns are excellent designs by definition). Why would I get any poorer designs from these techniques just because I didn't know the name of the pattern that might or might not be present anyway?

These insights helped hone my training process (and now my writing process). I had already been teaching my courses on several levels. I was teaching the fundamentals of object-oriented analysis and design. I did that by teaching design patterns and using them to illustrate good examples of object-oriented analysis and design. In addition, by using the patterns to teach the concepts of object orientation, my students were also better able to understand the principles of object orientation. And by teaching the guiding principles and strategies, my students were able to create designs of comparable quality to the patterns themselves.

I relate this story because this book follows much the same pattern as my course (pun intended). In fact, from Chapter 3 on, this book is very much the first day of my two-day course: Pattern Oriented Design: Design Patterns from Analysis to Implementation.

As you read this book, you will learn the patterns. But even more importantly, you will learn why they work and how they can work together, and the principles and strategies upon which they rely. It will be useful to draw on your own experiences. When I present a problem in the text, it is helpful if you imagine a similar problem that you have come across. This book isn't about new bits of information or new patterns to apply, but rather a new way of looking at object-oriented software development. I hope that your own experiences, connected with the principles of design patterns, will prove to be a powerful ally in your learning.

—Alan Shalloway

From Artificial Intelligence to Patterns to True Object Orientation

My journey into design patterns had a different starting point than Alan's but we have reached the same conclusions:

  • Pattern-based analyses make you a more effective and efficient analyst because they let you deal with your models more abstractly and because they represent the collected experiences of many other analysts.
  • Patterns help people to learn principles of object orientation. The patterns help to explain why we do what we do with objects.

I started my career in artificial intelligence (AI) creating rule-based expert systems. This involves listening to experts and creating mod-els of their decision-making processes and then coding these models into rules in a knowledge-based system. As I built these systems, I began to see repeating themes: in common types of problems, experts tended to work in similar ways. For example, experts who diagnose problems with equipment tend to look for simple, quick fixes first, then they get more systematic, breaking the problem into component parts; but in their systematic diagnosis, they tend to try first inexpensive tests or tests that will eliminate broad classes of problems before other kinds of tests. This was true whether we were diagnosing problems in a computer or a piece of oil field equipment.

Today, I would call these recurring themes patterns. Intuitively, I began to look for these recurring themes as I was designing new expert systems. My mind was open and friendly to the idea of pat-terns, even though I did not know what they were.

Then, in 1994, I discovered that researchers in Europe had codified these patterns of expert behavior and put them into a package that they called Knowledge Analysis and Design Support, or KADS. Dr. Karen Gardner, a most gifted analyst, modeler, mentor, and human being, began to apply KADS to her work in the United States. She extended the European's work to apply KADS to object-oriented systems. She opened my eyes to an entire world of pattern-based analysis and design that was forming in the software world, in large part due to Christopher Alexander's work. Her book, Cognitive Patterns (Cambridge University Press, 1998) describes this work.

Suddenly, I had a structure for modeling expert behaviors without getting trapped by the complexities and exceptions too early. I was able to complete my next three projects in less time, with less rework, and with greater satisfaction by end-users, because:

  • I could design models more quickly because the patterns predicted for me what ought to be there. They told me what the essential objects were and what to pay special attention to.
  • I was able to communicate much more effectively with experts because we had a more structured way to deal with the details and exceptions.
  • The patterns allowed me to develop better end-user training for my system because the patterns predicted the most important features of the system.

This last point is significant. Patterns help end-users understand systems because they provide the context for the system, why we are doing things in a certain way. We can use patterns to describe the guiding principles and strategies of the system. And we can use patterns to develop the best examples to help end-users understand the system.

I was hooked.

So, when a design patterns study group started at my place of employment, I was eager to go. This is where I met Alan who had reached a similar point in his work as an object-oriented designer and mentor. The result is this book. I hope that the principles in this book help you in your own journey to become a more effective and efficient analyst.

—James R. Trott

Read More Show Less

Customer Reviews

Average Rating 5
( 4 )
Rating Distribution

5 Star

(3)

4 Star

(1)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 4 Customer Reviews
  • Posted June 26, 2011

    Highly Recommend

    I found this book much more accessible than the GoF Patterns book. The author provides clear, easy to understand examples of how to use design patterns and when they are appropriate.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted October 31, 2008

    No text was provided for this review.

  • Anonymous

    Posted April 30, 2011

    No text was provided for this review.

  • Anonymous

    Posted June 30, 2010

    No text was provided for this review.

Sort by: Showing all of 4 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)