Programming Books C Java PHP Python Learn more Browse Programming Books
Qty:1
  • List Price: $69.99
  • Save: $21.54 (31%)
Only 9 left in stock (more on the way).
Ships from and sold by Amazon.com.
Gift-wrap available.
FREE Shipping on orders over $35.
Condition: Used: Very Good
Comment: SHIPS DIRECTLY FROM AMAZON! Eligible for FREE Super Saver Shipping and PRIME. Tracking is included. Easy return policy. As pictured. Very light edge wear. No marks throughout. Carefully packed and promptly shipped.
Access codes and supplements are not guaranteed with used items.
Have one to sell? Sell on Amazon
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 2 images

Analysis Patterns: Reusable Object Models Hardcover – October 19, 1996

ISBN-13: 978-0201895421 ISBN-10: 9780201895421 Edition: 1st

Buy New
Price: $48.45
27 New from $24.19 38 Used from $4.00 1 Collectible from $29.03
Amazon Price New from Used from
Hardcover
"Please retry"
$48.45
$24.19 $4.00
Paperback
"Please retry"
12%20Days%20of%20Deals%20in%20Books

Frequently Bought Together

Analysis Patterns: Reusable Object Models + Patterns of Enterprise Application Architecture + Refactoring: Improving the Design of Existing Code
Price for all three: $148.20

Buy the selected items together
NO_CONTENT_IN_FEATURE

Hero Quick Promo
12 Days of Kindle Book Deals
Load your library with Amazon's editors' picks, $2.99 or less each today only. Learn more

Product Details

  • Hardcover: 384 pages
  • Publisher: Addison-Wesley Professional; 1 edition (October 19, 1996)
  • Language: English
  • ISBN-10: 9780201895421
  • ISBN-13: 978-0201895421
  • ASIN: 0201895420
  • Product Dimensions: 7.8 x 1 x 9.6 inches
  • Shipping Weight: 2.2 pounds (View shipping rates and policies)
  • Average Customer Review: 4.3 out of 5 stars  See all reviews (17 customer reviews)
  • Amazon Best Sellers Rank: #415,092 in Books (See Top 100 in Books)

Editorial Reviews

Amazon.com Review

Patterns are higher-order designs that can be reused across projects and types of computer systems. Analysis Patterns: Reusable Object Models defines over 70 patterns, beginning with some from the business world, such as the Party and Accountability patterns, which define the players in organizations and whom they report to. Many of the other patterns are drawn from the health care industry and mainly show patterns of doctor-patient interactions.

The patterns for financial markets will probably be accessible for the majority of readers. Author Martin Fowler defines a Transaction pattern (and related patterns) as well as several patterns for the Accounting of Objects. He moves on to modeling stock markets with Portfolio, Quote, and Scenario patterns, which define how a price for a stock is determined for a given moment. Interestingly, he establishes patterns for Forward Contracts (for derivatives) as well as Options, and so takes on a complicated area in today's financial markets.

Fowler's considerable design experience in these fields is beneficial, as he is able to define each pattern in both text and software engineering diagrams. Only rarely does the author provide implementations of these designs and those that are furnished are done in Smalltalk, which makes this book more suitable for those who have experience in object design.

From the Inside Flap

Not long ago, no books were available on object-oriented analysis and design. Now there are so many that it is impossible for any practitioner to keep up with them all. Most of these books concentrate on teaching a notation, suggesting a simple process for modeling, and illustrating it with a few simple examples. Analysis Patterns: Reusable Object Models is a different kind of book. Instead of focusing on the process - how to do modeling - it concentrates on the result of the process - the models themselves.

I am a consultant in object modeling for information systems. Clients ask me to train staff on modeling and to provide mentoring on projects. Much of my skill comes from a knowledge of modeling techniques and how to use them. More important, however, is my experience in actually creating many models and regularly seeing problems repeat themselves. Frequently I find that many aspects of a project revisit problems I have faced before. That experience allows me to reuse models I have built before, improve them, and adapt them to new demands.

Over the last few years, more and more people have also become aware of this phenomenon. We have realized that the typical methodology books, though valuable, only present the first step in a learning process that must also capture the actual things that are built. This realization has flowered into the patterns movement. This is a varied group of people, representing many different interests and opinions yet sharing the goal of propagating useful patterns of software systems.

As a result of the diversity of this patterns community, we have had difficulty in defining the term pattern. We all think we can recognize a pattern when we see it, we think most of us would agree in most cases, but we cannot come up with a single definition. Here is my definition: A pattern is an idea that has been useful in one practical context and will probably be useful in others.

I like to leave the definition quite loose because I wish to stay as close to the underlying motivation of patterns, without adding too many restrictive amendments. A pattern can have many forms, and each form adds specializations that are useful for that kind of pattern. (Section 1.2 discusses the current state of the patterns world and where this book fits in.)This book is about patterns in analysis, patterns that reflect conceptual structures of business processes rather than actual software implementations. Most of the chapters discuss patterns for various business domains. Such patterns are hard to classify into traditional vertical areas (manufacturing, finance, health care, and so on) because they are often useful in several areas. These patterns are important because they help us to understand how people perceive the world. It is valuable to base a computer system's design on this perception and, indeed, to change that perception - which is where business process reengineering (BPR) comes in.

Conceptual patterns cannot exist in isolation, however. Conceptual models are only useful to software engineers if they can see how to implement them. In this book I present patterns that can be used to turn conceptual models into software, and I discuss how that software fits into an architecture for a large information system. I also discuss specific implementation tips with the patterns.

I wrote this book because this was the book that I wanted to read when I started out. Modelers will find ideas in this book to help them begin working in a new domain. The patterns contain useful models, the reasoning behind their designs, and when they should and should not be applied. With this information a modeler can adapt the models to fit a specific problem. The patterns in this book can also be used in reviewing models - to see what might have been left out and to suggest some alternatives that may lead to improvement. When I review a project, I usually compare what I see with the patterns I have learned from previous work. I have found that being aware of patterns in my work helps me to apply my past experiences more easily. Patterns like this also uncover modeling issues that go beyond what can be covered in a simple text book. By discussing why we model things the way we do, we gain a greater understanding of how to improve our modeling, even if we don't use the patterns directly.

Structure of this Book This book is divided into two sections. The first section covers analysis patterns, which are patterns from conceptual business models. They provide key abstractions from domains such as trading, measurement, accounting, and organizational relationships. The patterns are conceptual because they represent the way people think about the business, rather than the way a computer system is designed. The chapters in this section stress alternative patterns that can be used, and the strengths and weaknesses of those alternatives. Although each pattern will clearly be useful to those working in the same domain, the basic pattern is often useful in other domains.

The second section focuses on support patterns, which help you use analysis patterns. Support patterns show how analysis patterns fit into an information systems architecture, how the constructs of conceptual models turn into software interfaces and implementations, and how certain advanced modeling constructs relate to simpler structures.To describe these patterns, I need a notation. The appendix provides a brief discussion of the notation I use and what the symbols mean. I do not use a single method but prefer to mix techniques from different methods. The appendix is not designed to be a tutorial on techniques, but it should provide an outline and refresh your memory. It also tells you where to find a tutorial on the techniques I use.

Each section is divided into chapters. Each chapter on analysis patterns contains patterns that are related by a loose notion of subject area, influenced by the projects that spawned them. This organization reflects the fact that any pattern must come from a practical context. Each pattern appears in its own subsection within a chapter. I do not use any of the formal headings for patterns that are used by some patterns authors (see Section 1.2.2). I describe each pattern in a form that is as close to the original project form as is reasonable, with a minimum of abstraction. I add examples to show the use of the pattern within its original domain and also to suggest how the pattern might be used in other domains. One of the greatest difficulties of patterns is abstracting them into other domains; I follow the principle that this should be left to the reader (see Section 1.2.3).

This book is thus a catalog, rather than a book to be read from cover to cover. I have tried to write each chapter in such a way that it can be read independently from the other chapters. (This is not always possible, however. Whenever a chapter requires that another chapter be read first, I say so in the chapter introduction.) Each chapter has an introduction that explains the general subject area of the chapter, summarizes the patterns in the chapter, and says what projects the patterns originated from.

How to Read this BookI suggest reading all of Chapter 1 first and then reading each chapter introduction. Then feel free to delve into the chapters in any order you like. If you are not familiar with the approach I take to modeling, or the notation and concepts I use, read the appendix. The Table of Patterns gives a brief summary of what each pattern is about, so you can use that to help you explore or to find a pattern when you come back to the book at a later time. It is important to stress that each pattern in this book is useful outside the domain that gave it birth. Thus I encourage you to look into chapters that you might think are outside your field of interest. For example, I found that models of observation and measurement designed for health care proved to be very useful for corporate financial analysis.

Who Should Read this BookThis book can be useful to a range of readers, although different readers will learn different things from it and may need some different preparations.I expect my biggest audience to be analysts and designers of object-oriented (OO) computer systems, particularly those working at the analysis end. Such readers should have made at least some use of an OO analysis and design method. This book does not provide any introduction to this subject, so I would suggest first reading a book on OO analysis and design if you are new to this field. I must stress that the patterns in this book are conceptual in nature, and I use a very conceptual approach to modeling. This leads to some stylistic differences from those texts that use a more implementation-based approach to modeling.

A small, but very important, audience consists of those people who act as domain experts for a modeling project. Such readers do not require a knowledge of computers but do need to know about conceptual modeling. One of the main reasons I use conceptual models in this book is to make things easier for this group of readers. The modeling project here may be analysis for computer system development or BPR. I have taught many professionals (including doctors, financial traders, accountants, nurses, and payroll supervisors) this kind of modeling and have found that a software background is neither an advantage nor a disadvantage to conceptual modeling. The business model patterns are as much about business modeling as they are about computer systems analysis (see Section 1.4). Any such reader should take a course on OO analysis that stresses the conceptual aspect. (Odell's book Martin, J., and J. Odell, Object-Oriented Methods: A Foundation, Englewood Cliffs, NJ: Prentice-Hall, 1995 is particularly valuable in this respect.)

I hope many programmers will delve between these covers, although some programmers may take exception to the lack of code and the conceptual slant. For these readers I suggest you take particular note of Chapter 14, which should help to explain the relationship between the conceptual models and the resulting software.

This is an object-oriented book, and I do not hesitate in proclaiming my belief that the object-oriented approach is the superior way to develop software. These models, however, are primarily conceptual models, and many data modelers have had a long tradition of using conceptual (or logical) models. Data modelers should find many of the patterns useful, particularly if they use more advanced semantic techniques. The object-oriented features of the models will reveal many of the differences between object-oriented and traditional approaches. I would encourage such readers to use this book in conjunction with an OO analysis book that stresses the conceptual side of modeling and the links between OO and semantic data modeling.

Managers will find the book useful as a starting point for development activity. Starting from a pattern can help to clarify goals, and project planning can take advantage of the broad ground that patterns map out.

I have not aimed this book at students. I've written it more for the professional software engineer. I hope, however, that some students will take a look. When I was learning analysis and design, I found it difficult because there were few good examples I could learn from, examples that came out of the world outside the university. Just as looking at good code can teach you a lot about programming, looking at good models can teach you a lot about analysis and design.

A Living BookEvery author I know shares a frustration: Once a book is published it is fixed. The book spreads its advice around the community, yet the author has little way of expressing changes. I know how much I keep learning, and I am sure this learning will modify my ideas. I want these changes to be passed on to my readers.

With this book, Addison-Wesley will provide a web site which will be used to pass on further materials to keep this book alive. At this stage I am not sure exactly what it will contain, but I expect the following:

any new things I learn about the patterns in the book

answers to questions about the book

useful commentary from others about the patterns

new analysis patterns by myself, and by others

When the Unified Modeling Notation appears (or whatever it is called by then) I will redraw all the diagrams in the book in the new notation and put them on the site.

This site will be a complement to the book, so keep an eye on it and use it to let me know how to improve and develop the ideas between these pages.

AcknowledgmentsAny author is indebted to many others who help. For this book this is particularly true since so many of the patterns were built with the help of my clients, colleagues, and friends. I would like to give my sincere thanks to the following, both named and implied.First and foremost, Jim Odell has been an essential part of my career. He has taught me much about developing information systems and has been a constant source of inspiration, helpful advice, and strange humor. I can safely say that without his support this book would not have happened.

The team at Coopers & Lybrand in London helped with much of the early work and helped pass many evenings at Smithfield's.

John Edwards formed many of my early ideas about conceptual modeling and its role in software development, as well as introducing me to many interesting ideas, including those of Christopher Alexander.

John Hope urged me to think of the domain first and technology second, as well as casting a helpful spell at several key points in my career.

Tom Cairns and Mark Thursz, doctors at St. Mary's Hospital in London, worked with me in developing the health care models that form the basis of Chapters 2, 3, and 8. They are proof that a computer background is not necessary to be a top-class conceptual modeler. Mark also was a willing source for health care examples with impressive-sounding medical terminology.The health care projects also involved many software and health care professionals from St. Mary's, the Hospital for Sick Children (HSC), St. Thomas's Hospital, and the University of Wales. Anne Casey, a nurse at HSC, and Hazim Timimi, an analyst, helped put together the final Cosmos model. Gerry Gold set up this work and made sure it kept going.

Brad Kain has had a great impact on my thinking on reuse and components, as well as undertaking the important task of showing me the nightlife of Boston.

Applying the health care models to corporate finance in Chapter 4 was the experience that, for me, proved the usefulness of analysis patterns across different domains. Lynne Halpin and Craig Lockwood led the MBFW team at Xerox, and Vivek Salgar got our conceptual ideas into the brutal reality of C++.

David Creager, Steve Shepherd, and their team at Citibank worked with me in developing the models from which I drew the financial patterns in Chapters 9-11. They also further developed many of the architectural ideas of Chapter 12 from their health care origins, and taught me much about the frenetic life in The City.

Fred Peel set up and maintained my work at Citibank, when not scaring me with his driving.

Daniel Poon and Hazim Timimi from Valbecc got many of my fuzzy ideas into detailed specifications.

The accounting patterns in Chapter 6 have had a long gestation. Tom Daly, Peter Swettenham, Tom Hadfield, and their respective teams developed models that gave birth to the patterns in this book. Rich Garzaniti got my accounting terminology sorted out. Kent Beck did much to improve my Smalltalk.

Chapter 14 was written with the help of James Odell.

I have been very much a latecomer to the patterns community, getting to know it well only after most of this book was written. It is a very open and friendly group that has done much to encourage my work. Kent Beck, Ward Cunningham, and Jim Coplein encouraged me to get involved with the community and to develop my ideas as patterns. Ralph Johnson provided particularly helpful comments on the first draft of this book.

I have had first-class comments from my many reviewers whom I would like to name: Dave Collins, Ward Cunningham (Cunningham & Cunningham, Inc.), Henry A. Etlinger (Department of Computer Science, RIT), Donald G. Firesmith (Knowledge Systems Corporation), Erich Gamma, Adele Goldberg, Tom Hadfield (TesserAct Technology), Lynne Halpin (Netscape Communications), Brian Henderson-Sellers, Neil Hunt (Pure Software), Ralph E. Johnson (University of Illinois at Urbana-Champaign), Jean-Pierre Kuilboer (University of Massachusetts, Boston), Patrick D. Logan (Intel Corporation), James Odell, Charles Richter (Objective Engineering, Inc.), Douglas C. Schmidt (Washington University), and Dan Tasker. I will mention that Don Firesmith went above the call of duty in tracking down problems that needed to be fixed.

As this is my first book, I'm particularly grateful to those at Addison-Wesley who helped me through the process. Carter Shanklin directed affairs and assembled a formidable panel of reviewers with much assistance from Angela Buenning. Teri Hyde coordinated the book production on a painfully tight schedule and Barbara Conway rescued my prose from its usual erratic state, and ruthlessly eliminated my native accent.

0201895420P04062001


More About the Author

For all of my career I've been interested in the design and architecture of software systems, particularly those loosely classed as Enterprise Applications. I firmly believe that poor software design leads to software that is difficult to change in response to growing needs, and encourages buggy software that saps the productivity of computer users everywhere.
I'm always trying to find out what designs are effective, what approaches lead people into trouble, how we can organize our work to do better designs, and how to communicate what I've learned to more people. My books and website are all ways in which I can share what I learn and I'm glad I've found a way to make a living doing this.

Customer Reviews

Everybody I know who has read it likes it.
Ralph E. Johnson
This book condenses so much Analysis/Architecture/Modeling knowledge that it is difficult to come up with an idea to tackle the abstraction problem.
ws__
Martin Fowler has written the very first -- and still one of the best -- book on UML ("UML Distilled", now in its 3rd edition).
K. Victor Volle

Most Helpful Customer Reviews

49 of 53 people found the following review helpful By A Customer on April 29, 1999
Format: Hardcover
This is simply an excellent book; quite possibly the best book I have read on analysis.
Martin Fowler cheats by actually being able to write. He has a very lucid prose style making this a very readable book (a strength that also manifests itself in his book UML Distilled) even though it deals with complex subjects.
The book deals with using patterns to address particular business areas. However, it has a great deal to offer anybody interested in analysis or modelling (whether they are working in the OO world or not) and provides one of the best explanations I have read of the purpose and objectives of modelling.
Each problem area is presented very clearly and a number of different solutions are presented at different levels of abstraction (and hence complexity) with lots of useful insight into the factors that would determine the appropriate model.
Analysis Patterns is a book that bears reading and re-reading. I frequently refer it as an excellent source of interesting ideas on ways of approaching complex modelling & analysis issues. I have never managed to take one of the patterns and apply it as is; however, the ideas and concepts expressed in the book influence many of my models (even when the business problem I am tackling initially appears to be entirely unrelated to any of the patterns).
Frankly, this is a book I wish I had written.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
26 of 27 people found the following review helpful By Ralph E. Johnson on January 3, 1999
Format: Hardcover
I've got most of the books on patterns and find that this is the one I use the most. The writing is clear, the patterns address problems that I run into, and mostly the solutions are just what I need. This book is great to give to analysts who are having trouble agreeing with each other, because they often are persuaded by the book. It is great to give to analysts who are trying to master OO concepts, or to programmers who don't understand why things have to be so complicated. Everybody I know who has read it likes it. I just wish more people would read it!
The only thing I don't like about the book is the notation. I wish he had used UML. On the other hand, after you spend a few days with it, it isn't hard to understand. It is just one more notation.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
22 of 24 people found the following review helpful By Jed Reynolds on February 8, 2003
Format: Hardcover Verified Purchase
I bet you are an object oriented software developer striving to build better applications. If you have not read GoF <i>Design Patterns</i> and followed that with Vlissides's <i>Pattern Hatching</i>, read those first. Follow those with this, Martin Fowler's <i>Analysis Patterns</i>.
As two readings of <i>Design Patterns</i> took my OO knowledge from infancy to adolecence, <i>Analysis Patterns</i> will take you from adolecence to adulthood. Fowler's work does not put together patterns from the <i>Design Patterns</i> book, but takes its time to decompose actual application domain concepts to applicable object models. It will then be up to you to use your knowledge from <i>Design Patterns</i> to create mechanisms that support properly modeled business concepts as <i>Analysis Patterns</i> describes.
If you like OO modeling and design, but are wondering how better to apply your modeling concepts, Fowler's book is something you will definitely benefit from. However, make a pot of coffee per chapter-this book is very dense with concepts.
Fowler ends <i>Analysis Patterns</i> with some more easily read chapters on application design on a larger scale. You've heard of "n-tier," his discussion of the concepts of "n-tier" at the end of the book are possibly worth reading first.
After reading this book-and understanding it's motivations-you will never again be tempted to take "innocent" shortcuts in your application design. You will not be motivated to use "Strings" for "measurements" or "doubles" for "distances." You will look upon your peer's object designs either with a new understanding that they know that going the distance with their object model is worth it-and you won't demand they dumb down their design ever again-and you'll likewise gain intuition about where a simplistic business domain model is going to fail.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
14 of 15 people found the following review helpful By zak@radiks.net on August 16, 1997
Format: Hardcover
The analysis model is often forgotten. Too often designers will do just that -- design, i.e., solve the problem before serious inquiry into requirements analysis. This book addresses that which is between the use-case and detailed design model. It is the domain analysis model. Fowler is an excellent student of M. Odell, and it's high time that Odell's thinking was made accessible to the domain analyst. Fowler's book is general enough to get across the point that it is how we think about the problem that is the important part of modeling, and not some arcane "modelling process" that is significant to methodologists. A note about reusability, as pertains the title: to my mind it is this thinking which Fowler describes that is a part of modelling that is reusable. The output of his thinking, the actual models in his examples deriving largely from the financial domain, could be in fact reused. But it is the thinking that is important. The only bad thing I can say about this book is that I fear, by its title, it may not reach its desired audience of the domain analyst, because these are, quite frankly, the scientist, the doctor, the finance expert, etc. that can really benefit from modelling since they have the in-depth knowledge of the domain. It is the job of whoever reads this book to spread the message. Power to the domain analyst
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Most Recent Customer Reviews


What Other Items Do Customers Buy After Viewing This Item?