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.

Though small, thin, and expensive, this books packs a ton of useful information. It is well worth the price. UML is a complex subject and the authors do a great job with clear examples of what use cases (to a midlevel depth of complexity) should look like. Yes, the story that goes along with it is a bit hokey, but it makes for light reading between the mass of valuable and important data. I expect to use this a reference for quite a while.

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.

Back when, this was probably an OK book for the real novice - easy reading. Nowadays there are better ones, the Cockburn and Kulak ones contain real information. Get this one as an adjunct to the others and for the real basic intro.

This book will get you up to speed very quickly w/ the needed information to successfully write and use "use Cases". Although this is just one piece of the UML puzzle, this is a great piece to start out with!

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.

I liked this text. I'm a programmer, and may have increased project management responsibilities in the future. This book described an intuitive methodology that I feel confident about using.

Basically, they use the Rational Unified Process, and explain where use cases can be used at each juncture. They also get into some tricky situations, like denoting your error trapping in your use case, showing conditionals, etc.

I agree with the prior reviewer that said the dialogs of the fictitious project team got to be a little much. They were really painful to read.

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.

Great book for a practical and concise introduction to use cases. Also dwells on the UML methodology as far as the basic process for developing the order entry system goes. I had read other books on UML and use cases, but found them to be verbose and theoretical. This book can get you up and running in no time.

" Applying Use Cases : A Practical Guide" is not bad, but when I browsed through several Use Case books at a local book store, I decided to buy "Use Cases: Requirements in Context", which - to me - seems to be a far more practical book than this one.

Check out "Use Cases: Requirements in Context" before you buy any book on this topic.

If you assume that a use case scenario should contain a detailed written description of a user behavior then, perhaps, the book is for you. In my mind it is impractical and most of the time impossible. I disagree with an idea that primary scenario of an event should contain such a detailed description: "1. The use case starts when the customer selects Place Order. 2. The customer enters his or her name and address..... 7. Customer will select Submit... 9. When payment is confirmed, the order is marked as confirmed. an order Id is returned to the customer. and the use case ends."

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.

I AM CURRENTLY STUDYING A SYSTEMS ANALYSIS COURSE, THAT HEAVILY INVOLVES USE CASES. DURING MY LAST COURSEWORK I COULD NOT FIND A MORE ACCURATE AND INFORMATIVE BOOK THAN "APPLYING USE CASES:A PRACTICAL GUIDE". I FOUND THE TEXT A VERY WELL WRITTEN AND STRUCTURED BOOK. I FEEL WITH OUT THE BOOK I WOULD NOT HAVE RECEIVED SUCH A HIGH MARK. WELL WORTH THE MONEY. JUST SIMPLY THE BEST!

It is an easy to read and practical book. You can easily customize and apply its methods in your project.

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.

This is one book that does not make me bored. The topics are articulated through short, consistent, and related stories, which add the effectiveness of the book. If you want to learn about use cases and the UML User Guide does not give you complete understanding, then buy this book. It is worth it.

Be warned that this already-thin book contains wide swaths of "sample" documentation describing the project referred to throughout. Probably about forty or fifty pages of such. The rest of the content is good, however.

A aplicação de use cases em projeto OO é talvez onde se tenha maior a maior quantidade de dúvidas. Isso é natural pois o objetivo é mapear as necesidades do usuário para uma arquitetura de software. Li este livro em um fim-de-semana e já pude obter os benefícios dessa leitura na confecção de meus projetos. Um livro que precisa ser lido por todos aqueles que trabalham com use cases. Nota 10.

Never in my life did I imagine I would find a technial book that I could not put down. However, Applying Use Cases kept my interest from start to finish. In fact, I read the book in one day. Where other UML resources touch on the use case concept, Applying use cases goes into detail on the correct way to write and use use cases. The authors' writing style is easy to follow and the real world examples bring an otherwise fuzzy concept into sharp focus. If you find yourself needing to understand how to write use cases, this is the ONLY book you'll ever need!

I was very, very happy I'd read this book. It describes a simple and intuitive process for analyzing requirements with use cases, and where to go with use cases - to activities, sequences, and packages. I actually enjoyed the fictional dialog; I think it helped me mentally prepare for similar things my users may say.

A useful introduction to use case concepts in an easy to read style, although the case study dialog that other reviwers have mentioned does rather spoil the book - does it really matter that Tara can cook? (p12). However, overall a useful addition to your OO library - particularly as there are so few good books on the subject.

This is an excellent resource for those who apply uses cases in their design. It is very thorough, and detailed. Note, however that this is a book ONLY about Use Cases, don't expect any other technique. I would say that this is the most complete book on this subject. Should be used in conkunction with other techniques such as Object Modelling, etc. The end of the book contains a valuable information about cost estimating a project. This is definetely a reference book. Should be in your side while you are doing a JAD session or JAD documentation.

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.

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.

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.

This book was just what I wanted as introduction to object oriented use case technology. The example that was used throughout the book was almost exactly what I was looking for to begin the design of an "order processing" Web site. For those who may want to learn more after finishing this book, the resource list will be very helpful. Highly recommended.

Excellent short book with examples following the text. I would recommend the book for anyone needing an introduction to the usage of use case in software development. The only complaint is that the book is too short. With its small size, the areas that the authors declared as outside the scope of the book, could have been at least been discussed briefly. Also, there are several modeling tools now available that allow developers to create use cases and business rules and automatically generate object models. These also are not mentioned.