Applying Use Case Driven Object Modeling with UML: An Annotated e-Commerce Example is a practical, hands-on guide to putting use case methods to work in real-world situations. This workbook is a companion to Use Case Driven Object Modeling with UML. It bridges the gap between the theory presented in the main book and the practical issues involved in the development of an Internet e-commerce application.

Uniquely conceived as a workbook and featuring as a running example an e-commerce system for an online bookstore, Applying Use Case Driven Object Modeling with UML examines design in detail, demonstrating the most common design mistakes and the correct design solutions. The hands-on exercises allow you to detect, identify, and correct critical errors on your own, before reviewing the solutions provided in the book.

Structured around the proven ICONIX Process, this workbook presents a streamlined approach to UML modeling designed to avoid analysis paralysis without skipping analysis and design. The book presents the four key phases of this minimalist approach to use case driven design--domain modeling, use case modeling, robustness analysis, and sequence diagramming--and for each topic provides an overview, detailed discussion, list of common mistakes, and a set of exercises for honing object modeling and design skills.

The three chapters on reviews are also unique. The authors devote a chapter each to requirements review, preliminary design review, and critical design review. This focus on "designing quality in" by teaching how to review UML models fills a major gap in the published literature.

Through examples, Applying Use Case Driven Object Modeling with UML shows you how to avoid more than seventy specific design errors, as illustrated by the "Top 10" error lists included as a handy key on the inside covers and within each chapter. With the information, examples, and exercises found here, you will develop the knowledge and skills you need to apply use case modeling more effectively to your next application.

0201730391B08022001

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 4 Ratings

Learn object modeling by example with solution - 2001-06-29
Reviewer Rating:
All of the different jobs found in software development are learned in two ways. Either through trial and error on the job or by working through examples. The first is the most effective, but by far the most expensive. While the second is less thorough, it is cheaper and reduces the cost when you make the inevitable move to the first. Since object modeling is always open to many differing interpretations, learning how to create and use them has a slow learning curve. The best approach to learning how to model objects is to find and plow through detailed, complete examples, which of course presupposes that such examples exist. Well, they do and some of the best are found in this book.
The approach is one that maximizes the teaching effectiveness. An Internet bookstore project is created from the beginning. It is large enough to be instructive yet not so large that it becomes unwieldy. The authors then take you through the sequence of steps:

1) Domain Modeling, 2) Use Case Modeling, 3) Requirements Review, 4) Robustness Analysis, 5) Preliminary Design Review, 6) Sequence Diagrams, and 7) Critical Design Review.

What is different about this book is that after the explanation of the development stage, there is a top ten list of common errors made in that stage followed by an example described in UML. The UML diagram includes some of the errors in the list and they are pointed out and explained. This really drives the point of the error home.
The book is a distillation of the experience of the authors as they built a comparable system. They documented the complete process via videotape and then distilled their actions, including errors, down to the material in the book. This has led to some very good examples of how to model development at all stages and will certainly help you avoid some of the most common pitfalls as you make the treacherous, exhaustive and gratifying move from idea to product.

A practical follow-up - 2001-08-03
Reviewer Rating:
Okay. I became interested in the lightweight Iconix process after a series of 5 articles in Software Development magazine, so I went out and bought the first book "Use case driven object modeling with UML - a practical approach".

I design community based web portal applications. Our applications are medium-sized, but complex. So RUP is too big, and XP is too small. The Iconix process presented here is about right for most of our applications, and to satisfy client expectations for design.

The first book is more theoretical. This one has better, more complete, illustrative examples. There is some repetition between the two, but no pages are taken up by code. Like the first book, it is easy to read.

If you work in web development, read Conallen's "Building web applications with UML" also. The books complement each other well. (See my review)

Pricey for what it provides - 2002-01-15
Reviewer Rating:
I was excited about this book when I bought it online. Now that I read it, I am not very happy. The authors could have drilled deeper into some examples of how to implement the application using some wide spread technology like Java or ASP and COM. Giving concrete examples of what a Boundary Object should be, or what classes make sense to implement to interact with databases, just to mention a few, would have been very helpful. I also found "the top ten error" method very tiresome (I often skipped it and went straight to the right ways of doing things). The book was helpful though in providing a guide of what steps to follow in the design process as well as giving us a good idea on how to break the project into objects and diagrams.

An expense that can be justified. - 2002-05-24
Reviewer Rating:
You are already into various Java technologies like
Servlets, JDBC, EJBs and can put together a
small to medium application/project using those.

You somehow implemented the project/app to
satisfy the requirements but you are thinking
that there has to be a better way of going from
a set of requirements to a design (from which the leap to
actual coding is smooth) without feeling like
some vague unrepeatable 'magic' was being done.

You want to formalize the process of jumping from the
'analyze' phase to a 'Object oriented design' phase (that
results in sequence/collaboration diagrams etc) but
without being encumbered by an elaborate and complex
methodology.

You want this process to be small, easy to understand
and flexible so that you can adapt it to your needs.

If the above applies, you should seriously consider
investing in this book.

The Authors use the often used bookstore example to drive
home the process which starts with writing usecases
and ends with a detailed design that satisfies all the
user's requirements.

A list of 10 common mistakes made during each step of
the process can be used as a reference when you are
done understanding the process and are actually applying
it in your projects.

Paul Reed's Application Development with Java and UML
makes a good complement to this book, though
Conallen uses a modified but still complex enough form
of Rational Unified Process (RUP) in his book.

Browse Similar Topics

Top Level Categories:
Programming
Software Engineering

Sub-Categories:
Programming > UML
Software Engineering > OOP
Software Engineering > UML