countdown boutiques-francophones Learn more vpcflyout Furniture All-New Kindle sports tools

Customer Reviews

4.3 out of 5 stars
4.3 out of 5 stars
Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

on October 24, 2003
Over the last year I have come to love Use Cases ... I write them before embarking on any software development project, large or small. The first taste I got of Use Cases was in the "UML Distilled" book (Fowler, Scott).
My favorite aspect of "Applying Use Cases" is how it follows a hypothetical project from Inception to Transition phases. The authors provide the reader with a clear idea of how Use Cases fit into the software development process as a whole, rather than just providing some templates for producing Use Case documents without instructions on their use.
The best, and worst, thing about books in the Object Technology Series (of which "Applying Use Cases" and "UML Distilled" both belong to) is their brevity. The concepts are conveyed very clearly and concisely, but it feels like I should be getting more substance ... .
Overall, this is a wonderful book and belongs on the shelf of any Software Engineer or Project Manager. It goes well with "Extreme Programming Explained" and "A Practical Guide to Extreme Programming", two of my favorites in this genre.
0Comment| One person found this helpful. Was this review helpful to you?YesNoReport abuse
on November 12, 2002
As someone who has followed the development of UML and Use Cases for the past several years and who is now confronted with a project needing definition, I find the Scheider-Winters book very helpful -- not only in applying Use Cases, but also in defining the project itself.
I chose this book because I know Geri Schneider-Winters as a professional (we worked together at UCSC Extension.) I was not disappointed.
0Comment| One person found this helpful. Was this review helpful to you?YesNoReport abuse
Given the proper instruction, working with use cases is not as hard as it may appear. Demonstrating them requires a large, detailed example to illustrate how complex structures can be reduced to understandable chunks. Therefore, the most critical part of any book on how to apply use cases is the choice of the system to model. That feature is what makes this book stand out.
The premise is that several people, with some experience in designing systems, but certainly not experts, decide to build an order processing system. Choosing a group of non-experts is a stroke of genius, since it allows the authors to use dialog based on the premise of learning as you go, which describes most of us. This approach makes it much easier to relate to their trials and tribulations as they plunge in over their head, only to be rescued by the proper applications of use cases.
Requirements are iteratively added as needed or discovered, demonstrating how iterative development is superior to others such as the waterfall. The developers are learning the background while constructing their system. Elaborating on their initial model is a slow and steady process, however it is not without the frequent step back. These glitches are presented in a realistic format with sections devoted to common mistakes made when using use cases.
A great deal of effort is also expended in describing how refined the use cases should be. One of the topics in the section on common mistakes is making the use cases too small. Like anything else, they can be split down to the point where they complicate rather than simplify. With no fixed rules to guide the process, you are forced to rely on more common sense notions. This is always hard, but some good, effective guidelines are given.
I found this book to be a superb introduction to the power of use cases, being easy to follow. Everyone from beginners to veterans can relate to the principals as they struggle to turn their good idea into an implemented one. You find yourself rooting for them as they move ever closer to their brass ring of success. In that respect, it is less like a technical book and more like a novel.
0Comment|Was this review helpful to you?YesNoReport abuse
For every abstraction used in the development of software, there is a definition and a set of rules concerning how to use it. Unfortunately, being an abstraction, the definition is often open to interpretation and the rules are nebulous guidelines. The concept of use cases is one such abstraction. Therefore, the best way to explain them is to use them in an understandable context. That is the approach taken in this book.
The scenario is that a group of designers want to build a "simple" online ordering system. They begin with the proverbial conversation over coffee which contained the usual, "that system stinks and we could do better" phrase. From there, a general, but fairly complete process is presented. Every step in the sequence of requirements definitions is given. Many potential use cases are put forward, which is excellent, as this allows the authors to demonstrate the culling process, whereby some use cases are eliminated and others are combined.
The presentation is a combination of simulated dialog between the principals and more formal techniques of requirements capture such as actors and their diagrams. One thing that impressed me was the accuracy of the dialog. Anyone who has participated in the requirements capture process will experience a flashback. It is written with the beginner in mind, as very little programming background is needed to understand it. This is a thorough demonstration of how to create and apply use cases, without the depth that requires more formal notational techniques.
Use cases are sometimes very hard to teach, as is the case with most abstractions. In this book, the abstract is made concrete and if you read it you will learn a lot about use cases. However, you still may not be able to offer a precise definition.
0Comment|Was this review helpful to you?YesNoReport abuse
on October 8, 1999
This book will give you a great foundation for applying use cases and does so in a format that is to the point and user friendly. The book is only about 180 pages and does well with this amount of space. It doesn't attempt any great tangents of though or reason bit stays focussed on use cases and the relevant material that is associated with the subject. Two points that could be strengthened in the book are: 1) the level of abstraction that you are applying to the use case at a particular time and how this may evolve over time, 2) there could be a little more structure provided for traceability throughout the project lifecycle. Both points are mentioned but the authors never really provide a structured mechanism to handle these issues, which would be a complex requirement for all but he simplest projects. I thought the ongoing fictional case study approach was a great idea. It allowed the reader to catch their breath along the way and also provides for some contextual insight that can be missed in a strictly academic format. Although not directly related to this title, "Designing Object-Oriented Software" by Wirfs-Brock, et. al. is also right on the nose with using a responsibility driven approach and CRC cards. It's a good read by itself but especially in combination with Applying Use Cases.
0Comment|Was this review helpful to you?YesNoReport abuse
on November 13, 2000
Summary: If you've got plenty of $$ go ahead and buy it to get a good, simplistic start but you will need more. I've been doing requirements for quite a few years now and am convinced that use cases are the way to go especially for interactive systems. The key reason being that it forces the analyst to focus on WHAT the system should do rather than the HOW it should do it(I fall in that trap quite often). This particular book uses a different writing method, more story telling in nature. Some people may like it ... I don't care for it personally because the time spent reading Jane and Billy's annoyingly pleasant and simplistic banter could be better spent playing with my kids. It does, however, get around to giving a good academic introduction to the topic but the lack of examples severely hinders it from living up to a level of "practicality" to warrant the inclusion of the word in its title in my opinion. If you are a "just give me some guidelines and show me some good examples and get out of my way" kind of person, this book will make good kindling for your next BBQ -- especially if your software will involve any remotely complex scenarios. Perhaps the problem is that I tend to conceptualize systems in too complex a manner ... but it would be nice if the book helped in that regard as well by educating me relative to pitfalls that may lead me to overcomplicate things. In the end (couldn't finish the book) I find myself still looking for a good book mostly one loaded with realistic, practical, applicable examples.
0Comment|Was this review helpful to you?YesNoReport abuse
on November 2, 1998
This book provides an excellent introduction to practical application of use cases. Most UML-related books hardly devote a chapter to use cases and use examples which are so elementary they provide little practical value. Applying Use Cases is devoted entirely to the subject of use cases (analysis, rather than design). It touches on design at the boundary between analysis and design and discusses this transitition point. It discusses use case development as an iterative cycle which doesn't end when design begins. Design may uncover more use cases when then need to be anaylzed and the developer(s) must iterate through use cases again.
The book uses an online ordering system as an example for building use cases. It presents this fictitious project from inception through to the point of design. This project is large enough that it works well with the topic. It provides enough detail to understand how important use cases are and how much effort should be devoted to them. However, it is not so complex that a UML beginner would have difficulty following it. It is fairly easy reading for a technical book and can be completed in a day. Reading it twice was helpful for me.
The little dialogs between the make-believe project team is perhaps a little overdone, but I think it works well in the context of the subject. This presentation style presents the "roots" of use cases fairly well. These types of dialogs are almost always part of the process even though they go undocumented.
As with all methodologies, UML included, the analysis of requirements is the most important step. Doing a poor job on use cases will lead to a poorly implemented software system. This book is the best I've seen covering use cases, the UML analysis method. I highly recommend it. I would like to see a follow-on book with a much more complex example which delves into more detail on use cases.
0Comment|Was this review helpful to you?YesNoReport abuse
on October 19, 1998
This book provides an easy-to-digest introduction to use case development. I wish it had been available when I first began employing use cases. The consistent example of the order entry system -- neither too complex nor too simple -- was helpful in understanding and applying new concepts. However, the fictional example of a team of people meeting periodically to go through the use case exercises was amateurish at its best and painful at its worst. The editors could have cut it entirely, with no loss in readability or understanding. Good dialog is very difficult for even skilled novelists. In my humble opinion, it would have been far more effective had the author pushed the unintentially comical dialog into a full, campy diversion from the topic at hand. Despite this literary faux paxs (presumably provided by the second-billed Jason Winters), Geri Schneider writes with clarity and anticipates questions well.
0Comment|Was this review helpful to you?YesNoReport abuse
on August 17, 2000
After reading through the sixth chapter of this book the light bulb goes on and suddenly you start to understand how everything fits together using the UML and Unified Process (UP). This book is the how-to of applying UML and UP where as the Unified Modeling Language Users Guide and the Unified Software Development Process are the foundation on which to build this understanding. If you read the two previous mentioned books first and then read Applying Use Cases then the overall brilliance of using a modern use case driven, architecture-centric, iterative/incremental software development process will fall into place. This book is the missing link for UP and UML.
0Comment|Was this review helpful to you?YesNoReport abuse
on November 19, 1998
As another reviewer pointed out, the campy dialog that this book relies on to help guide you through the process of developing use cases sometimes hinders the cause more than it helps. Luckily, you can either skim or ignore it altogether and still garner valuable insight into the process of using use cases. This book has served as my read-along guide for a current project and I have found the chapter outlining the final use case documentation for the books' fictional project to be a great aid. I wish there were more books on this topic, especially some with 'real-life' use cases that led to successful projects, but this book is a very good place to start.
0Comment|Was this review helpful to you?YesNoReport abuse

Need customer service? Click here