Sponsored links

Valid XHTML 1.0!
Valid CSS!

Product: Book - Paperback
Title: Agile and Iterative Development: A Manager's Guide
Publisher: Addison-Wesley Professional
Authors: Craig Larman
Rating: 5/5
Customer opinion - 5 stars out of 5
Brilliant effort

Craig Larman has covered the breadth and depth of agile methods. The hint's and tips are invaluable. A Great book.

Product: Book - Hardcover
Title: Digital Image Processing (2nd Edition)
Publisher: Prentice Hall
Authors: Rafael C. Gonzalez, Richard E. Woods
Rating: 5/5
Customer opinion - 5 stars out of 5
A comprehensive book for almost everyone

The book gives a comprehensive treatment on image processing and covers the appropriate amount of information. The depth of materials was appropriate for someone already familiar with basic signal and probability theories. This is definitely the book to keep as reference if you plan to work in the area. An additional chapter on image reconstruction will be extra helpful.

Product: Book - Paperback
Title: Writing Effective Use Cases
Publisher: Addison-Wesley Professional
Authors: Alistair Cockburn
Rating: 4/5
Customer opinion - 4 stars out of 5
The power of providing real-world examples

If there's one book that can be credited with popularizing use cases, this is it. Alistair Cockburn shares his applied knowledge in `Writing Effective Use Cases' and does so in a very digestible format. This is a handbook, a self-study guide - one full of real-world examples and exercises (with solutions even!) that any analyst or designer can relate to.
Use cases are a form of documenting systems requirements and behavioral design specifications. Written well, they offer benefits to all who participate in the development life cycle. This includes analysts, designers, project managers, developers, testers and even end users. Mr. Cockburn's book takes the reader through the writing process, highlighting both good and bad examples. He makes no claims that any of these examples are perfect. And that is perhaps the greatest element of his book. Commit yourself to read through all the examples. By the time you're finished studying them, you will find your own skills in identifying what makes a `good' or `bad' use case have been sharply honed.
Perhaps the one area this book does not explore in enough detail is the translation of documented use cases into user interface designs. Mr. Cockburn defers to `Software for Use' (another great book) for this. Even so, I would like to have seen some screen shots and comments about the user interfaces that were created from the examples provided. It would have helped tie the whole picture together. Translating use cases to highly usable interfaces is as much an art as it is a science. I believe this element of use-case driven development is best communicated in a live, face-to-face format. That's why organizations like Classic Systems offer workshops on this topic. As an instructor who teaches use case-driven development, I have found `Writing Effective Use Cases' to be invaluable reference tool. Having tried out a number of Mr. Cockburn's ideas in the classroom, student feedback and learning results have shown me just how potent a learning tool this book can be.
Many designers and developers will tell you they are writing use cases; upon closer inspection, we find very few are writing them well. A poorly written use case can actually cost, rather than save, a project time and money. If your looking for a book that will help you and your team harness the benefits of use cases, this one is a good as it gets.

Product: Book - Paperback
Title: Working Effectively with Legacy Code
Publisher: Prentice Hall PTR
Authors: Michael Feathers
Rating: 5/5
Customer opinion - 5 stars out of 5
Simply supurb, a tour de force

The vast majority of software texts are about greenfield development: creating a new application from nothing at all. But the vast majority of software work involves existing code: adding features, finding bugs, or refactoring code that someone else wrote. This book is a supurb first step in fixing that imbalance.

This is not a theoretical work. For example, Feathers does not present a grand ontology of legacy systems. Not is this book heavy on methodology. Instead Feathers describes techniques --- lots of techniques, roughly 50 --- for working with legacy code.

The techniques are organized by the problems they address. For example, one chapter is entitled "My Application Is All API Calls" and then presents two techniques for working with existing code that is full of calls to APIs.

Feathers comes from the XP school, and he adopts that school's premise that you can safely change code if (and only if) there are sufficient tests in place to tell you when your new change has introduced a bug. Many of the techniques in this book are about different ways of putting legacy code into test harnesses, and doing that safely without introducing bugs along the way.

He also introduces new concepts, or at least concepts I had never seen before. For example, a "characterization test" is a test that characterizes the actual behavior of the code, not what the code is supposed to do, but what it actually does. Why is that useful? First, it is an effective way of documenting what a system actually does, particularly if --- as with most legacy code --- there is no other documentation. And it can tell you when you have changed that existing behavior.

Feathers' style is easy to read. As you would expect there is lots of example code here, and it is folded naturally into the explanatory text. My only gripe with the book is with the examples: they are largely in Java, C++, or C. I would have liked some examples in older legacy-only languages, like COBOL.

But overall, this book is simply supurb, a tour de force of an important topic that has received little coverage before.