Customer Reviews

Designing Highly Useable Software

5 star:		(3)
4 star:		(0)
3 star:		(1)
2 star:		(1)
1 star:		(1)

 

 

If you're looking for a book on general software design, this book won't help you much. This book is about creating usable software, not software in general. It's very hard to pinpoint what makes something usable, but Jeff does an outstanding job. I liked the fact that he often augmented a technical lesson using stories that make learning the details fun. The manner of presentation is interesting because Jeff doesn't rely on just one technique to present the information. The details are often illustrated using several methods, so it's easier to understand precisely what Jeff means. Unlike many theory type books, this one has source code examples--something that every developer can relate to.

The chapters that I liked best appear at the end of the book. They discuss topics that many developers really don't know about, but should. For example, Jeff takes time to point out a need for online help and tells you why training is important. Of course, someone could make an argument that developers do very little training, but if they don't understand what makes software easy to teach to users, the software will never become usable.

No, this won't be the only software design book on your shelf, but you owe it to yourself to make this book part of your collection. This is the book that every developer should read after reading a general software design book. The world could certainly use more usable software and Jeff shows you how.

If you've read Alan Cooper's excellent "The Inmates are Running the
Asylum", you're familiar with the format of "Designing Highly Useable
Software": the main text talks about broad useability issues, while
entertaining (or frightening) sidebars pillory the flaws in the design
of everyday things. But whereas I sympathized with Cooper, I had
trouble identifying with Jeff Cogswell. The sidebars, meant to be
amusing, are mostly distracting: they are rarely relevant to the main
topic being discussed on the same page. Worse, Cogswell goes much too
far in complaining about the difficulty of living in the world around
him; the reasonable reader won't recognize himself in these vignettes.
Worse still, whenever this book steps away from abstract useability
discussions and into coding specifics, technical errors appear that
shake the reader's confidence.

I had high hopes for this book. Perversely, I expect slimmer books to
be better than fatter ones. At a relatively slim 300+ pages, I looked
forward to a good read packed with useful advice. Instead, the book
dragged on. The last five or six chapters (on such topics as dynamic
libraries, OOP, management, and training -- all with a heavy emphasis
on an outdated, waterfall-like development methodology) feel precisely
like padding. The first half-dozen alone, with more specific
useability advice and fewer suggested implementation details, might
have formed the basis of a far better book. But as it stands, I can't
recommend this book.

I definitely recommend the book to all programmers who want to make their software more useable to the end users, which hopefully is the goal of every programmer :). The tone of the book is casual yet informative making it very easy to read unlike the hoards of other books on the market. Best of all, the author is a real programmer, probably the reason why the content is very pertinent to situations encountered by programmers and the decisions that they have to make routinely. This book provides them the tangible points to consider while making those decisions as topics ranging from User Interface design to exception handling to libraries are discussed. The author uses various practical examples and humor to drive the point home. This book is a must read for any programmer!

Book Review: Designing Highly Useable Software by Jeff Cogswell - Sybex 2004


This is a book review of Designing Highly Useable Software written by Jeff Cogswell and published by Sybex in 2004.As a programmer and novice web designer who sees firsthand the user experience disconnect between software creationist and the users of said software any material concerning creating better software interests me. Software usability measures the ease, or pain, with which a user facilitates their desired task with the given software. Designs and computer researchers have given this field of study more focus in recent years under the names of user interaction experience (uix) or human-computer interaction (hci). While a lot of usability focuses on the web recently Cogswell's book is a little older and focuses mostly on desktop usability issues.

This book is of little use to everyone except for beginning software designers. It does contain a handful of code listings. However, since they don't add much to the discussion the beginning user interface designer's understanding would not be hindered either. The book focuses mainly on the desktop user interface with rather mundane discussions of artifacts such as taskbars, shortcuts, dialog boxes, window layouts. When Cogswell delves deeper into coding issues that manifest themselves in usability he often gives questionable advice. For example, in Chapter 8, "Under the Hood", he suggests programmers place system calls to sleep functions inside their for loops because, "if you're writing scientific software...that goes through a lot of calculations, you run the risk of overheating somebody's poor laptop." Later he gives "some starter code" for an undo system, which is not much use for such a non-trivial task. Here a more general dissection of the benefits and drawbacks of example undo-systems and their side effects would benefit the reader more. A lot of the code talk contains platitudes such as "avoid overly complex code", "clean up resources appropriately", and "handle all exceptions". The code talk varies from obvious to borderline erroneous and seems to be included mostly as filler or to placate the author's ego.

The writing style Cogswell uses makes another strike against this book. Cogswell wordy nature makes the book longer and more meandering than necessary. As another reviewer mentioned the callout side notes in each chapter serve little purpose other than padding the book's length. Cogswell liberal use of personal humor makes for a dry read too. The book could be condensed and still contain the same amount of useful info.
The shelf life of this book is very short. The book focuses mostly on windows applications, going so far as to talk about window cascading and dissect the windows versioning system. In the future users will move to mobile and web application computing so this book shall be less useful. Also in the future where most programming languages used to write software don't use pointers and allow the programmer to devote less thought to typing and garbage collection the C++ code examples become less useful, especially those that concern linked list of pointers and resource cleanup.

This book was a disaster from the start. It contains mostly common sense usability advice. Where newer usability research makes use of heat maps, eye tracking, and survey results Cogswell advice seems to be mostly anecdotal based. For anyone incorporating usability research into improving their interface designs this book offers no help.

I'm not sure who this book would appeal to. The advice is mostly common sense and useful to novice designers. The code snippets require a basic understanding of C++ the beginner might not have. I cannot recommend this book and my suggestion would be to spend your money elsewhere on a book with fresh ideas and real research.

I finally finished reading this book, and I have to say, in time it will give the other usability books a run for their money. This book is written for programmers, and the goal of the book is to help us programmers step into the shoes of the users. The other reviewer couldn't relate to the stories, but I sure could. The author fills the book with funny stories about strange things he's encountered over the years that have frustrated him. These stories show what it's like to be a user. When you take this knowledge and apply it to programming, you start to understand how to build software for the user. Also, unlike other usability books, this one actually gets into some programming, with real-live code samples in C++! This guy really *is* a programmer. He even talks about design patterns, and methodologies like the Rational Unified Process. Get this book, read it, and start making great software.

This volume covers valuable topics in a readable manner. It should be useful to anyone who develops applications, interfaces, and documentation. 

But how in the world can the author justify both "useable" and "usability" in the same book? Good style requires consistency in spelling. If "usability" is the noun, then "usable" is the adjective (see the Microsoft Computer Dictionary as well as many other dictionaries and technical style manuals).

Something this sloppy should have been taken care of in editing, especially when one of the words is in the book title!! Doh...