This innovative book recognizes the need within the object-oriented community for a book that goes beyond the tools and techniques of the typical methodology book. In Analysis Patterns: Reusable Object Models, Martin Fowler focuses on the end result of object-oriented analysis and design—the models themselves. He shares with you his wealth of object modeling experience and his keen eye for identifying repeating problems and transforming them into reusable models. Analysis Patterns provides a catalogue of patterns that have emerged in a wide range of domains including trading, measurement, accounting and organizational relationships.
Recognizing that conceptual patterns cannot exist in isolation, the author also presents a series of 'support patterns' that discuss how to turn conceptual models into software that in turn fits into an architecture for a large information system. Included in each pattern is the reasoning behind their design, rules for when they should and should not be used, and tips for implementation. The examples presented in this book comprise a cookbook of useful models and insight into the skill of reuse that will improve analysis, modeling and implementation.
|Product dimensions:||7.40(w) x 9.00(h) x 0.70(d)|
About the Author
Martin Fowler is an independent consultant who has applied objects to pressing business problems for more than a decade. He has consulted on systems in fields such as health care, financial trading, and corporate finance. His clients include Chrysler, Citibank, UK National Health Service, Andersen Consulting, and Netscape Communications. In addition, Fowler is a regular speaker on objects, the Unified Modeling Language, and patterns.
Table of Contents
(NOTE: Each chapter concludes with References.)
The World of Patterns.
The Patterns in this Book.
Conceptual Models and Business Process Reengineering.
Patterns and Frameworks.
Using the Patterns.
I. ANALYSIS PATTERNS.
Accountability Knowledge Level.
Party Type Generalizations.
3. Observations and Measurements.
Subtyping Observation Concepts.
Dual Time Record.
Active Observation, Hypothesis, and Projection.
Process of Observation.
4. Observations for Corporate Finance.
Phenomenon with Range.
Using the Resulting Framework.
5. Referring to Objects.
6. Inventory and Accounting.
Individual Instance Method.
Posting Rule Execution.
Posting Rules for Many Accounts.
Sources of an Entry.
Balance Sheet and Income Statement.
Specialized Account Model.
Booking Entries to Multiple Accounts.
7. Using the Accounting Models.
Implementing the Structure.
Setting Up New Phone Services.
Setting Up Calls.
Implementing Account-based Firing.
Separating Calls into Day and Evening.
Charging for Time.
Calculating the Tax.
Proposed and Implemented Action.
Completed and Abandoned Actions.
Outcome and Start Functions.
10. Derivative Contracts.
Subtype State Machines.
Parallel Application and Domain Hierarchies.
11. Trading Packages.
Multiple Access Levels to a Package.
II. SUPPORT PATTERNS.
12. Layered Architecture for Information Systems.
Presentation and Application Logic.
13. Application Facades.
A Health Care Example.
Contents of a Facade.
14. Patterns for Type Model Design Templates.
Design Templates for Other Techniques.
15. Association Patterns.
Appendix A. Techniques and Notations.
Appendix B. Table of Patterns.
Most Helpful Customer Reviews
This is Martin Fowler's first book, published in 1997. The book is divided into two large sections. The first section details analysis patterns that Fowler has encountered across industries. These chapters cover several common domain patterns including representing organizational hierarchies, inventory, accounting, and others. Fowler approaches these chapters by starting with a simple model and repeatedly expanding on this model to fit more and more complex needs. This section of the book is interesting from an academic and a practical perspective. It was interesting to see how Fowler has approached different domain problems and I expect to reference these chapters as I tackle similar problems in the future. The second section of the book covers what Fowler calls Support Patterns. In these chapters Fowler discusses tiered architecture, presentation layers, facades, and association patterns. The second section on support patterns is less useful and some chapters are quite dated. While this information may have been useful in 1997, if you are looking for more information on layered architectures read Enterprise Application Architecture - a more recent book by the same author. I found this book to be quite good. I enjoy Fowler's style of writing and for the most part I found the book easy to follow. However, this is Fowler's first book and it lacks the polish of his more recent other books -- in a few spots it was hard for me to follow the author's train of thought. This book predates UML and the diagrams used throughout the book take a while to understand. There is a key to the models on the inside cover of the book, but if the diagrams had been updated to UML they would have been easier to understand. If needed, you can find UML diagrams for this book on Martin Fowler's website. I think sample code would have helped clarify some of the models as well, as was used in the 'Gang of Four' book. If you are designing a domain model for a complex business, I think this book would be useful for you. If you are looking for similar books, I would suggest Design Patterns by Gamma, et al. ('Gang of Four' book), Patterns of Enterprise Application Architecture, and Refactoring both by Fowler.
Analysis Patterns devotes a number of chapters to describing how the basic (core) elements of trading systems might be modeled in an OOP environment. When, I first read those trading chapters in Martin's book a year ago, I didn't find the material easy going. It was only later, I came to truly understand and appreciate much of the material after I had a chance to work on some additional releases of a large trading system. The fact that some of the material is presented in the style of a college text book by referencing other works didn't help my original efforts to understand it. However, I will say, that if you are involved in the modeling or building of an OOP trading system, (and use some modeling language such as UML), then this book is a good buy. The more experience you have with trading applications the easier the read will be. Most importantly, it outlines some keep practical considerations to modeling trading systems. Now that I'm involved with designing a new trading system, I'm again busy reading Martin's book. In fact, I've just bought an additional copy for the office. In the future, I'd love to see more on domain models for businesses.
Unique reference describing patterns as applied to the analysis phase of software development.