Customer Reviews

Why Software Sucks...and What You Can Do About It

5 star:		(10)
4 star:		(3)
3 star:		(3)
2 star:		(2)
1 star:		(6)

 

 

I never heard of David Platt prior to reading this book. His title as a Harvard professor in software design prepared me for a dry and technical book on software design.

I'm happy to say there is nothing 'dry' or boring about Mr. Platt's writing style. The book is easy to read and you'll find yourself nodding along with the examples he gives. Why do we accept poor software design? I failed to even recognize bad software until Mr. Platt specifically pointed it out. At which point, I smacked myself in the head and said "of course!"

If you are an average computer user and wonder why things are the way they are, this book is for you. If you are a programmer who wants to write successful software that average computer users will praise, this book is for you.

On the other hand, if you are a technical user or programmer who can do no wrong, heaven forbid you pick up a book that has the potential to broaden your horizons.

In my opinion, this is one of the best books on software design that is written with humor and analogies to make it easy for anyone to understand and show them what they can do about it.

Thank you, Mr. Platt. The industry has been needing this book since computers went mainstream back in the early 1990's.

Finally, a voice from the silent majority!

As an Engineering/Management professional who regularly works with software developers, I picked up this book hoping for an interesting read with maybe a few pearls of wisdom that might benefit someone in my position. I held no false impression of this being a management text; I was merely looking for insights. Also, I confess that I enjoyed the boldness of the title. (You marketing guys: always messing with our heads!)

In this regard, Platt did not disappoint. While essentially reaffirming much of the knowledge and many of the beliefs I held regarding software development and the truly creative people who do it for a living, the author tossed out enough new thoughts, peppered with a sense of humor welcome enough to keep me engaged.

Individuals not familiar with the process of software development will no doubt find the content even more illuminating. The author is spot-on in his assessment of where software developers go wrong, having witnessed it myself over many years in product development.

If this book had been a more difficult read, I would have been disappointed. As it is, "Sucks" was an enjoyable, quick read with just enough substantive content to be worth my effort. That is, it had decent balance--time investment vs. intellectual return.

I would gauge this book as being targeted at (or most appropriate for) the knowledgeable, but not necessarily expert, software user. Readers in this group are likely to have an informative and enjoyable experience.

Although targeted towards explaining to ordinary people why computer software is hard to use, Why Software Sucks...and What You Can Do About It by David S. Platt is something that software developers would do well to read and understand how we blow it on a regular basis. Five words... The. User. Is. Not. You.

Contents: Who're You Calling A Dummy?; Tangled In The Web; Keep Me Safe; Who The Heck Are You?; Who're You Looking At?; Ten Thousand Geeks, Crazed On Jolt Cola; Who Are These Crazy B@st@ards Anyway?; Microsoft - Can't Live With 'em And Can't Live Without 'em; Doing Something About It; Epilogue; About The Author

Platt takes a look at software and web sites from the perspective of the user, someone who's just trying to get something done. And his overwhelming conclusion is... software sucks. In large part, this is because the computer geeks who design the software are completely mistaken as to who is the target user. They design something that works for themselves, thinking that everyone thinks and reacts as they do. They think that complexity is cool, and whiz-bang features should be appreciated in and of themselves. The reality is that the basic user does *not* think like a computer geek, and they get tired of sites that make no sense or make them work (or rework) for the reward at the end. Using good/bad site contrasts such as Google (guesses the language to use based on the IP address/location) vs. UPS (ask for your country EVERY SINGLE TIME before you can do anything), it becomes quickly apparent when a site's been designed by computer geeks rather than design/interface specialists who are able to think like a user. Armed with this book, a person can start to understand why things are harder than they need to be, and what steps can be taken to make your displeasure known. It may not change anything, but being silent isn't a viable option either.

Now for computer software designers like myself, this book can be humbling. I think I've done a few of the things he condemns, and I found myself rethinking (*and* changing) a few of my website project features after reading this. I realized I was forcing the user to understand my world before they could do something. And if I couldn't explain it well, how did I expect them to grasp it? But aside from being a useful and extremely funny book, there's one chapter that was a joy to read. Ten Thousand Geeks explains the concept of software conferences and what they're like. Furthermore, he talks about what it's like to be a speaker at one; the joys, trials, and adrenaline rushes that come with being in front of people and mingling with your speaker peers afterwards. It was like reading my own story, and it was incredibly accurate. I would love to print out about five paragraphs of that chapter and post it with the title "This Is Why We Speak At Conferences." That chapter was worth the price of the book by itself...

I wouldn't hesitate to recommend this book to someone on a number of levels and for a number of reasons... Well worth the time spent reading it.

Ok I'll admit it... I'm a geek. I'm one of those guys that David writes about. Some geeks have a hard time facing the truth but that is always the first step in change.

David calls 'em as he sees 'em and does it in a style that will leave you laughing all the way. If you have found yourself frustrated by the way software works and wondering what geeks like me were thinking when we built it - this book is for you.

If you are a geek wondering why average people seem to dumb to figure out your masterpiece you really need this book. No it does not include the latest algorithms and design patterns just a good old fashioned dose of reality. Swallow it please - this medicine may taste awful but trust me it will be good for you in the long run.

For many people, using a computer includes awkward events such as the infamous Windows blue screen of death, applications crashing, unintuitive interfaces, viruses and spyware, and other horrendous interactions. If commercial airplanes were designed in the same way many software applications are, we would never get on them. Of course, if a plane was designed in such a manner, it would never even be able to leave the gate.

In Why Software Sucks...and What You Can Do About It, David Platt explains why the situation is so bad. Platt notes that one of the many reasons software is so poor is that the software architects, managers and programmers who develop it don't understand their customers anywhere as well as they should. This disconnect from the customer means that software developers often add features customers don't want or need, and attempt to solve the wrong problems in the first place.

This misconceptions means that programmers will often make control over the application a top priority, over usability. This in turn renders complex things possible, as opposed to making the simple things simple.

The underlying message of the book is that computing is not necessarily a technology field, but rather a people field. Platt notes that it is crucial not to push technology for its own sake, rather for finding real problems to solve.

While written about software developers, the book is jargon-free of techno-geek-speak and written in an easy to read style. Platt references many real-world examples of applications and web pages that don't perform as well as they should.

For a book on a technical subject, the author brings significant humor to the table. As you read story after story of poorly written software, you will laugh as you can likely relate to the stories.

The book concludes by showing what you can do to stop the madness. Unfortunately, this requires a lot of time and commitment on the user's part. The effort to stop the madness of poorly written software is going to take a revolution as the book describes.

Overall, Why Software Sucks...and What You Can Do About It is an entertaining book that has significant value for anyone using applications software. While not written just software developers directly, let's hope over time, they take heed to the author's sage advice.

As a middling software designer myself, I decided to buy this book after someone recommended it to me. It did not disappoint! This book is not quite intended for the programmer or the developer; but it's still a good read for all types of computer user.

The book describes how so many applications and websites fail their users. David Platt reveals this as the book progresses, and he makes very good points. Software does suck. You may not agree with him on all the points (sometimes confirmation boxes are necessary, in my opinion), but I think if we developers take off the rosy, geeky (maybe X-ray?) glasses, we can recall all the times we've become frustrated with programs we don't understand. And we need to understand that most users don't understand our programs' logic, nor should they have to.

That is why this book is essential for any developer to read. It gives plenty of examples of websites and software features that are unnecessary and pointless. It also gives more abstract theories about why this is so. Mr. Platt doesn't beat around the bush in showcasing "what not to do."

Unfortunately, since this book is aimed at the average user, it does not list many specifics on how to solve these problems. Don't expect to buy this book and know how to solve accessibility problems with HTML, or how to fix security blunders with a complex crypt cipher. That isn't the intention. To be aware of the problem is the book's aim, and that's enough for me.

And, most importantly, it makes you laugh, time and again. I was chuckling most of the time I was reading this book. It truly is a gem, if you can appreciate it.

In fact, I daresay that the people who will get the most use out of this book are the developers. We can understand what Mr. Platt is saying. The average computer user will appreciate the humorous examples, and perhaps be driven to demand better from the developers, but it is the programmer who can sit back and think to himself, "My God, I've been doing it all wrong."

David Platt is a riot. I have heard him lecture at conferences and teach many classes. He is a software legend (literally) and a master teacher. He is both a hilarious geek as well as a geeky comedian.

The book is a well organized collection of observations, full of humor and wit. But it very practically points to many underlying problems with software and software development. Every developer should read this to understand the traps they fall into -- then they can avoid them. Customers of software developers should buy a copy for every developer on the team. It's worth every penny. And it's a fun read too.

Non-technical people will find they have a friend and advocate on the inside. Anybody who uses a computer will relate to the frustrations of poor design. And this book is written to be very accessible to the non-technical audience. Platt's other books are targeted toward programmers (yet are well sprinkled with humor). This book is for everyone who uses a computer.

Managers: It would make for a nice bonus to give out this book at the year-end review. Much better than the cheese-moving elephant-dancing, tipping-point stuff that everyone else gives. This book will be appreciated.

In fact my (non-technical) wife is enjoying the book now, and is beginning to understand me (scary!).

This book is both funny and instructive at the same time. As a computer language trainer I always recommended it to my students, even if they would have hard time to translate it (English is not their mother tongue) because it covers a lot of things that they sooner or later will have to pass through their lives while coding. It is also a nice way to remember us, veterans developers, why there is so much lame software in the world.

The first chapter is a good short entry on software design. Some good points are made, though most people who are interested in the topic will find the same ideas in Alan Cooper's books or Donald Norman's. Then a series of chapters on security make it clear that this book wasn't written as a whole, but as a series of unconnected essays. Some facts are repeated a few times showing a need for more editing.

A couple of the essays toward the back of the book are better, so long as you don't expect to learn much about software, and software quality. I don't recommend this book.

This is a great that points out so many of the shortcomings of current software. I recommend it to all developers out there that swear they do everything right and everyone else does everything wrong (you know who you are!).