Customer Reviews

Applying UML and Patterns - The Complete Video Course (Boxed Set)

5 star:		(98)
4 star:		(40)
3 star:		(4)
2 star:		(9)
1 star:		(7)

 

 

Craig Larman did a splendid job simplifying UML. I bought this book along with the official UML user guide and I prefer reading this book because of how it made UML look so easy. What's so impressive about this book is that the author stays with one example throughout the book, and clearly illustrates the relationships and dependencies amongst different UML diagrams and artifacts. He even shows you how to map the diagrams to actual Java code! Larman's explanations of the different design patterns is also invaluable. I haven't heard of design patterns before, and this book helped me have a deeper appreciation of patterns to create better object-oriented software.

This book is the best introduction I have seen to object-oriented analysis and design. It explains the 'Unified Process' of analysis and design, including UML and the use of patterns. I am a big fan of this book because it emphasizes the "why"--the reason for each element of the process from a business perspective. For example, instead of simply offering a recipe for writing use cases, the book talks about why one might include or exclude specific elements to achieve specific objectives.

Those (like me) who have avoided Unified Process because it looks too rigid, bureaucratic, and form-laden will love this book. The author argues convincingly that UP is best implemented in an iterative process that looks more like Extreme Programming than the cumbersome waterfall process one typically associates with UP. Then the book shows how to implement a UP process in enough detail, with enough examples, and with enough flexibility, that a project leader can readily put this form of UP into practice.

I have avoided UP for years, but this book may have made a convert out of me. It's the first book I have seen that makes an effective business case for UP and presents a practical guide to its implementation. I have no hesitation recommending it to anyone, from novice project leaders to seasoned software architects.

Craig Larman provides the reader with simple, easy-to-follow examples of UML and pattern application, with few deep theoretical or philisophical discussions of development process. This style offers the new user of UML a good guide to applied modeling concepts, without bogging he/she down in academic arguments. If you are going to buy a single book to learn UML, I highly recommend this one, as it goes beyond simply describing the notation, and illustrates its use through simple guidelines. Other books are necessary to fully understand the complexities of UML, patterns, and design process, but this one fills a huge gap for the beginner market.

This book IS what the subtitle says: An Intro to OO Analysis and Design and the Unified Process. It is a GREAT introduction. It also uses patterns and does a good job of explaining why various approaches are what *good* programmers do. But it does strike me that the main title was invented to get the most "hits" on a variety of searches one might try. It's not primarily about "applying UML" which is a good thing, despite the title. It does use UML as its notation whenever notation is needed and it explains the usage well. I am using this book as a text in the first of a 3-course graduate series on software engineering. The reactions from students (all with industry experience, most without OO experience) have been quite positive. The use of an example that runs throughout the book provides a vehicle for getting deeper and deeper into certain topics. Larman writes in a very readable style but he doesn't write "down" to the reader. His motivations for various techniques/approaches are reasoned and appropriate. He references excellent books as well. As the professor, I have used some of these to develop certain topics more deeply in my accompanying lectures.

I feel ripped off. I was excited to see that this well-rated book had appeared in course form, and bought it to help my development group get started with UML and thinking in terms of design patterns. The book is interesting, and the tapes are not bad, but there are only about 3 hours of tape. This means that the examples are all very simple and there is only time to lightly touch on each topic. Personally, I don't consider 3 hours and 25 minutes -- minus the time spent on administrative matters -- to be anything close to a "complete video course." I'm a big fan of the idea of video courses, but in this case I feel like I paid 3 to 4 times as much as the price of the book just to get a few hours of introductory video that aren't enough to help us out. Come on, Prentice Hall -- you can do better than that! You guys know how to provide good value -- do it! Until then, my recommendation is to buy the book and spend the rest of the money on something else.

Despite the main title, this book is not just about the UML (UML is not OOA/D or a method, it is SIMPLY NOTATION).

The book helps a developer learn core skills in the art and science of building object systems, rather than notation.

In fact, it is not so helpful to learn syntactically correct UML diagramming, but then not be able to create an excellent design, or evaluate, or improve an existing one. This is the harder and more valuable skill.

"How should responsibilities be allocated to classes of objects? How should objects interact? What classes should do what?"

These are some critical questions in the design of a system.

Knowing an object-oriented language is a necessary but insufficient first step to create object systems. This book helps a developer: Apply principles and patterns to create better object designs; Follow a set of common activities in analysis and design; Create frequently used diagrams in the UML notation.

It is easy to run out of space just by listing the topics introduced in this book, nevertheless here are some of them: OO fundamentals, UML 1.4, design patterns, Unified Process, domain modelling, mapping of design-to-code (Java), architectural analysis, framework design and the list goes on... The content is organised in 6 parts, including a total of 36 chapters spread over 600+ pages. Long book, many topics... If you are after a quick or thorough description of a single topic then naturally this is not the right reading.

The core offering of the book is the middle 4 parts that describe the analysis & design of the case study (a POS system). We are taken through the inception and 3 iterations of the elaboration phase of the UP. It is almost minimalist-UP, as the emphasis is on just doing what is necessary and not creating text/ diagrams for documentation purposes only; the code is the ultimate real model. Naturally, use-case driven, iterative and incremental development is highlighted. In addition, during the OOAD, we are taught how to harness the UML and not only shown the notation and elements that it contains. A good number of patterns are described, again while being applied to the case study, from the GRASP (essential if your background is not OO) to the GoF patterns and many others. The title and subtitle of the book are definitely justified.

The author explains all techniques very well and provides precise definitions and examples that hit the spot. In fact, every decision taken when designing for the case study builds on notions previously introduced, thus demystifying OO design; Craig Larman proves it to be a science and not art or magic. Furthermore, numerous references are given for the principles illustrated as well as pointers for further reading (which sometimes are needed given the introductory nature of the writing).

In reality, few developers are completely agnostic to all the topics covered in this book (and if they are, then it is the perfect read). Hence, given the intertwined exploration of all areas, few readers are going to avoid reading about material they already know. Following from the previous point, it is natural that the book does not serve as the best of reference titles; although its well-organised index, glossary and in-cover tables/ diagrams do help. In any case, this excellent book would make an ideal university course book.

The book is a perfect balance of UML diagrams and artifacts, and code. Larman guides through each step of gathering user requirements, analysis, design, and coding. The mapping of diagrams to the actual code is very impressive. Larman makes UML look so easy. Book follows one point-of-sale example and illustrates the development cycle step by step.

This is a very good introductory level text on object-oriented software analysis and design, software patterns and the Unified Modeling Language (UML). I used this book to study for a certification test, but its worth reading even if you don't have a test hanging over your head. The writing is clear and the book is well organized with many useful diagrams and tables. Larman guides the reader through the most important phases of a software project using a point of sale (POS) system case study. The case study is well chosen because its problem domain is familiar to most people and it has enough interesting aspects to illustrate the use of the Unified Process, application of design patterns and the UML very well. Time reading this book will be well spent. You will not only bet a better understand of how to use the process and tools, but also why and when they are useful. I have only two minor criticisms: The index seems inadequate making it a little harder than necessary to use as a reference, and its bias toward the Java programming environment when reference is made to implementation specific issues.

Craig Larman's writing style is extremely friendly. It might appear initially - as it did to me - that the book is repetitive. But, as I persevered I realized that the book quite justifiably reiterates those fundamental concepts that bear repetition because they desperately need to be driven home.

This painstakingly well-produced book is an absolute pleasure to read as it introduces a veritable barrage of concepts at an ever-so-gentle pace suitable for an introduction.

Once you've been introduced to domain models, use-case models, assigning responsibilities, design models, implementation models, patterns, and UP all using the industry standard UML and Java code, you're truly ready to tackle those advanced books (like Design Patterns by Gamma et al) that we all want to read but cannot really appreciate without a proper grounding in the fundamentals.

Larman has taken great pains to keep this book on the cutting edge of technology. He continually refers to the latest advances in all the related technology areas. He also lists the most appropriate references to the best books and research papers in the respective fields.

As a practitioner with 12 years of experience developing and architecting software systems, I unhesitatingly give this book my HIGHEST RECOMMENDATION!