Vous voulez voir cette page en français ? Cliquez ici.

Have one to sell? Sell yours here
Tell the Publisher!
I'd like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

UML Distilled: A Brief Guide to the Standard Object Modeling Language [Paperback]

Martin Fowler , Kendall Scott
3.9 out of 5 stars  See all reviews (69 customer reviews)

Available from these sellers.


Save Up to 90% on Textbooks
Hit the books in Amazon.ca's Textbook Store and save up to 90% on used textbooks and 35% on new textbooks. Learn more.
There is a newer edition of this item:
UML Distilled: A Brief Guide to the Standard Object Modeling Language (3rd Edition) UML Distilled: A Brief Guide to the Standard Object Modeling Language (3rd Edition) 3.8 out of 5 stars (11)
CDN$ 32.75
In Stock.
Join Amazon Student in Canada


Book Description

Aug. 25 1999 020165783X 978-0201657838 2
The award-winning first edition of UML Distilled was widely praised for being a concise guide to the core parts of the UML and has proved extremely successful in helping developers get up and running quickly. UML Distilled, Second Edition, maintains the concise format with significantly updated coverage of use cases and activity diagrams, and expanded coverage of collaborations. It also includes a new appendix detailing the changes between UML versions.
Written for those with a basic understanding of object-oriented analysis and design, this book begins with a summary of UMLs history, development, and rationale and then moves into a discussion of how the UML can be integrated into the object-oriented development process. The primary author profiles the various modelling techniques in the UML, such as use cases, class diagrams, and interaction diagrams and describes the notation and semantics clearly and succinctly. He also outlines useful non-UML techniques such as CRC cards and patterns. These descriptions are made even more relevant with a collection of best practices based on the primary authors experience and a brief Java programming example demonstrating the implementation of a UML-based design. With this tour of the key parts of the UML, readers will be left with a firm foundation upon which to build models and develop further knowledge of the Unified Modeling Language.

Special Offers and Product Promotions

  • Join Amazon Student in Canada


Customers Who Bought This Item Also Bought


Product Details


Product Description

From Amazon

The second edition of Martin Fowler's bestselling UML Distilled provides updates to the Unified Modeling Language (UML) without changing its basic formula for success. It is still arguably the best resource for quick, no-nonsense explanations of using UML.

The major strength of UML Distilled is its short, concise presentation of the essentials of UML and where it fits within today's software development process. The book describes all the major UML diagram types, what they're for, and the basic notation involved in creating and deciphering them. These diagrams include use cases; class and interaction diagrams; collaborations; and state, activity, and physical diagrams. The examples are always clear, and the explanations cut to the fundamental design logic.

For the second edition, the material has been reworked for use cases and activity diagrams, plus there are numerous small tweaks throughout, including the latest UML v. 1.3 standard. An appendix even traces the evolution of UML versions.

Working developers often don't have time to keep up with new innovations in software engineering. This new edition lets you get acquainted with some of the best thinking about efficient object-oriented software design using UML in a convenient format that will be essential to anyone who designs software professionally. --Richard Dragan

Topics covered: UML basics, analysis and design, outline development (software development process), inception, elaboration, managing risks, construction, transition, use case diagrams, class diagrams, interaction diagrams, collaborations, state diagrams, activity diagrams, physical diagrams, patterns, and refactoring basics.

From the Inside Flap

Two years ago, Addison-Wesley approached me to write a book about the then-new UML. At that time, there was a lot of interest in the UML, but only a standards document from which to learn about it. We broke many records to quickly produce a short introductory guide to the new UML, something that would provide some guidance until the more detailed and official books were to appear later that year.

We didnit expect this book to last after more detailed books appeared. Most people believed that given the choice between a slim overview and a detailed text, everyone would pick the detailed text. Although that was the general view, I believed that even in the presence of detailed books, there was still room for a concise summary.

Two years later, my hopes have been realized more than I could have wished. UML Distilled has been, in computer industry terms, a best-seller. Even though good detailed books have appeared on the UML, the book still sells well. Better than that, more slim books have appeared, confirming my belief that in a world with so much information, there is value in well-chosen brevity.

Now, thatis all very well, but should you buy this book?

Iim going to assume youive heard about the UML. It has become the standard way to draw diagrams of object-oriented designs, and it has also spread into non-OO fields. The major pre-UML methods have all died out. The UML has arrived and is here to stay.

If you want to learn about the UML, this book is one way to do it. The main reason for starting with this book is that itis a small book. Buying a big book will give you more information, but it will also take you longer to read. Iive selected the most important parts of the UML so that you donit have to. With this book, youill pick up the key elements of the notation and what they mean. If you want to move further, you can move to a more detailed book later.

If you want a longer tutorial to the UML, I suggest the Unified

Modeling Language User Guide (Booch, Rumbaugh, and Jacobson 1999). The User Guide is able to cover a lot more ground. Itis well written and organized in a way that explains how to apply the UML to various modeling problems.

Both this book and the User Guide assume that you know something about OO development. Although many people have told me that this book is a good introduction to objects, I didnit write it with that in mind. If youire looking for an introduction to objects with the UML, you should also consider Craig Larmanis book (Larman 1998).

Although the main point of this book is the UML, Iive also added material that complements the UML material. The UML is a relatively small part of what you need to know to succeed with objects, and I think that itis important to point out some of the other things here.

The most important of these is software process. The UML is designed to be independent of process. You can do anything you like; all the UML does is say what your diagrams mean. However, the diagrams donit make much sense without a process to give them context. I also believe that process is important and that a good process doesnit need to be complicated.

So, Iive described a lightweight outline process for OO software development. This provides a context for the techniques and will help to get you going in using objects.

The other topics include patterns, refactoring, self-testing code, design by contract, and CRC cards. None of these are part of the UML, yet they are valuable techniques that I use regularly. Structure of the Book

Chapter 1 looks at what the UML is, the history of its development, and the reasons why you might want to use it.

Chapter 2 discusses the object-oriented development process. Although the UML exists independent of process, I find it hard to discuss modeling techniques without talking about where they fit in with object-oriented development.

Chapters 3 through 6 discuss the three most important techniques in the UML: use cases, class diagrams, and interaction models. The UML is a large beast, but you donit need all of it. These three techniques are the core that almost everyone needs. Start with these and add the others as you need them. (Note that since class diagrams are so complicated in themselves, Iive put the key parts of class diagrams in Chapter 4 and the advanced concepts in Chapter 6. )

Chapters 7 through 10 explore the remaining techniques. All of these are valuable, but not every project needs every technique. So these chapters provide enough information to tell you what the technique is and whether you need it.

For all of these techniques, I describe the notation, explain what the notation means, and provide tips about using the techniques. My philosophy is to make clear what the UML says and, at the same time, to give you my opinions on how best to use it. Iive also added pointers to other books that provide more detail.

Chapter 11 gives a small example to show how the UML fits in with programming using (of course) Java.

The inside covers summarize the UML notation. You may find it useful to refer to these as you are reading the chapters so that you can check on the notation for the various modeling concepts.

If you find this book interesting, you can find other information on my work related to using the UML, patterns, and refactoring at my home page (see page xxi). Changes for the Second Edition

As the UML evolved, and I received feedback about the first edition of the book, I continually updated it. We reprinted every two or three months; nearly every printing contained updates, which resulted in considerable strain on the processes of the publishing industry.

With the change from UML 1.2 to 1.3, we decided to do a more thorough overhaul of the book, enough to produce a second edition. Since the book has been so popular, Iive tried not to change the essential spirit of the book. Iive carefully tried to not add much, and to see whether there are things I can take away.

The biggest changes are in Chapter 3, about use cases, and Chapter 9, about activity diagrams, which have each received a severe rewrite. Iive also added a section on collaborations to Chapter 7. Elsewhere, Iive taken the opportunity to make a host of smaller changes, based on feedback and my experiences over the last couple of years.


Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

Customer Reviews

Most helpful customer reviews
5.0 out of 5 stars an excellent handy reference Sept. 28 2003
Format:Paperback
There are hundrends if not thousands of articles and tutorials floating around on the net which are written on or around or about UML, some try to cover everything in a shallow manner, some try going deep into a very specialized aspect of one kind of diagrams. As a software architect, people like me need something concise and handy which we can constantly refer to which chalking out different diagrams which are required in software project following RUP methodology, this book serves this purpose in an excellent manner and I am certainly happy using it for the last couple of projects I handled.
One thing I must say is that I found the coverage of 'Development Process' (Ch 2) very sketchy and superficial, and most probably it does not even belong in a book so focussed in being used as a reference for a software project.
There is only one more thing which I expected from this book. Different UML diagrams are sketched and used in different stages of a project, if only these were overlapped with RUP project phases (inception, elaboration, construction and transition) along with a representative of other documents used in those phases the use of the UML diagrams could have been realized from a better perspective.
I would highly recommend the book 'Building J2EE Applications with RUP' (Peter Eeles, Kelli Houston and Wojtek Kozaczynski) for the J2EE practitioners, these two books complement each other very well in the J2EE/RUP world.
Was this review helpful to you?
5.0 out of 5 stars An excellent and classic book Sept. 14 2003
Format:Paperback
First of all, please let me confess that I happen to be a fan of Martin Fowler's writing style. I feel he has an uncanny ability to get things over to his readers. But this book is more than style.
It follows an approach based on Pareto's 80/20 principle (which in the present instance translates into what would have been a statement like "there is 20% of UML syntax that you will need 80% of time and this is what I am going to teach you.") Following that tenet, this thin book (fewer than 200 pages) succeeds in its goal of being a very good distillation of the basics of UML, and thus an excellent introductory book to this graphical notational language.
Since this is an introductory book, a good thing about it is that it provides ample references to other publications for those inclined or required to delve in more depth into specific aspects of UML and OO analysis and design. There is a tendency to prescribe books from Addison-Wesley's Object Technology Series (part of which this book is), but I guess that is something to be expected.
Actually, the book, despite its small size, is not strictly constrained to UML per se. In its introductory chapter, it discusses the broader issue of OO analysis and design, where it succeeds in providing some background to the uninitiated, as well as providing the necessary context for UML, which without OO is like a fish out of the water. In the next chapter Fowler moves on to discuss process (RUP) - where RUP, of course, is not necessarily confined to the OO realm - stressing however that "the UML is independent of process" (p. 14). Within this discussion he offers some sidebar discussions of related issues such as Self-Testing Software, Refactoring (one of his favorite subjects), and Patterns.
Read more ›
Was this review helpful to you?
1.0 out of 5 stars another poor author Aug. 1 2003
Format:Paperback
To somebody who knows OOP, UML can be explained in under 30 minutes.
It is simple, OOP is not. OOD starts in the head of an OOP programmer. Patterns help!
I heavily recommend Sams "Teach Yourself UML in 24 hours"
ISBN 0672322382
Make up your own mind by looking at the books locally first.
Whoever wrote the Schaum's Outline on UML also engages in doubletalk that is convoluted and based on something in the head of the author. Too bad Stephen Prata, Stephen Kochan, Ivor Horton or Bruce Eckel didn't write on patterns or UML!
So many books by Booch, Fowler and Larman are heavily padded...full of repetitious sentences that tell me nothing!
A professor at a local university said "I read Booch's 1992 book on OOA 3 times and asked myself what I learned...nothing"
Those are my words exactly!
When I was in Junior High, there was a teacher whose punishment for chewing gum was to write a 10 page essay on the benefits of chewing gum. I'll tell you I never chewed gum. Can you imagine how much you have to pad the writing to get 10 pages.
Concerning a recent Booch book, I emailed Grady Booch to ask where the black diamond (in an early chapter) was defined. A month later, back came "chapter 16". Good thing I already knew about aggregation and composites.
These people just can't write.
Why are there so many fans of these books?
There is honor amongst thieves, elitists and groupies!
Was this review helpful to you?
4.0 out of 5 stars A Good Distillation and Reference May 23 2003
Format:Paperback
I read the 1st edition of the book several years ago and this 2nd edition just recently. This book is a very good summary of the most commonly used UML diagrams and notation. It's a handy refresher for those who have already studied UML in detail and need a quick, practical reference. It may also work for those who are unfamiliar with UML, but need a quick primer on how to read UML diagrams. It's much less effective as a tutorial for using UML. The writing is clear and concise. Chapter 2 is a good summary of the development process, touching the high points and offering some useful tips. (The author recommends Craig Larman's book "Applying UML and Patterns" for a more in-depth introduction to Unified Process. I agree with that recommendation.) Chapters 3 - 10 (which cover the diagrams and notation) are the most useful. Chapter 11 "UML and Programming", is not very effective in trying to bridge UML work to programming. It either needs more detail, or should have been omitted entirely. Its primary accomplishment seems to be the author's facetious intention to "get Java into this book somehow" (p. 148).
Was this review helpful to you?
Want to see more reviews on this item?
Most recent customer reviews
1.0 out of 5 stars A Terrible Guide - Even if a "Brief Guide"
This book is a terrible guide to UML. The authors constantly give their opinions on components of UML and fail to define or illustrate the components clearly or accurately. Read more
Published on Feb. 9 2004 by Brandon M Tosch
4.0 out of 5 stars Really good, concise intro to UML
This small book is a great introduction to UML, with real-world applications. It's concise and easy to understand for the novice (me). Read more
Published on Aug. 13 2003 by Glen Ford
5.0 out of 5 stars Introduction to UML
Best introduction in UML. Easy and complete (for almost 99% of UML you ever use). Buy it!
Published on July 25 2003 by Claudio Rivera
2.0 out of 5 stars less than inspiring
This book was less than inspiring but had some useful ideas. The following paragraphs briefly document these ideas. Read more
Published on May 16 2003
5.0 out of 5 stars For me, this was all I needed to get up to speed with UML
As a developer trying to improve my coding skills I was looking for a quick overview of UML to get me up to speed with it so I could apply simple modelling to my software projects. Read more
Published on April 8 2003 by Laurens
4.0 out of 5 stars Ideal book for UML begginers/intermediate
Very easy book to read. Fowler and Scott are good writers.
Be a favor to yourself if you are an UML begginer: buy it.
If you want take the IBM 486 test, its enough. Read more
Published on April 3 2003 by E. Bengtson
3.0 out of 5 stars Not for the 486 exam
I bought this book to prepare the IBM 486 exam and I don't think it's a good choice.
The subjects are exposed in a disordered way that may be ok for a first approach, but not... Read more
Published on Jan. 23 2003 by ANDRES LANDA
2.0 out of 5 stars mediocre
There is really a sore need of a book that can teach UML modelling with a NO-[nonsense] kind of approach. Alas, the tendency is not this one... Read more
Published on Jan. 20 2003 by Riccardo Audano
3.0 out of 5 stars Confusing
I guess this isn't a bad book, but it's not great either. I found it way too confusing. The O'Reilly UML In A Nutshell book was much more helpful for me. Read more
Published on Oct. 30 2002 by Jason C. Norman
Search Customer Reviews
Only search this product's reviews

Look for similar items by category


Feedback