To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzes reviews to verify trustworthiness.
Today, much of our lives depend on software. However, people, in average, are actually not that good at building software and a lot of things can go wrong. With this book, Gojko points out that they have gone wrong, over and over again. Mistakes in software has caused a lot of pain, suffering, money and sometimes lives.
In Humans vs Computers, Gojko Adzic shares a collection of stories about software gone wrong. Of systems behaving the wrong way, crashing, turning off, sending tickets to the wrong place, making wrong transactions, declaring people dead who are still alive, and other horrible things. This was often because the developers of the system didn't imagine the particular use of the system. They didn't understand the customer and the customer domain well enough. To them it probably seemed like a trivial thing but the impacts on people's life can be huge.
The books is structures around stories. Stories of similar themes are grouped together which also creates a bit of a flow between the stories. The book ends with simple tips for developers to avoid these kind of mistakes.
I thoroughly enjoyed reading about the stories. Some of them were just funny and others were shocking. All of them were written really well. For just the book about the stories, I'd rate it as 4 stars. But the ending with the summary on how to prevent this changed the book from a story book to one that probably every developer ought to read. 5 stars and recommended reading!
I did two 5 hour train trips and the book proved awesome reading. I did the whole thing in two gulps!
Needless to say, I love the book. It's a great idea and the author tell the stories with such a wonderful tone and humor. The last chapter adds a nice touch of usefulness to the book as I get some very practical (and now funny) tips on how to avoid the problems described and make a more trustworthy, reliable and stable system.
This is a book full of stories seasoned developers love to tell each other in the after-the-talks-pub. Keep one close and you'll be the center of attention at any good conference bar.
I'm reading each page with a gentle smile on my lips, bursting out in laughter every few pages. What a bizarre world of exceptions we live in. What a mess we create trying to shoehorn that exceptional world into conformist models of the computer.
In the "February 2038" chapter I could not control myself anymore; I created an event called Boom on 1/2 2038. A lot of strangeness happens with the calendar input control on an iPhone after that ... Fun to be able to break systems in real time!
Reviewed in the United States on September 15, 2017
As I was enjoying this book, I realized that in my long career in software development I had seen a previous writer who wanted to sound a wake-up call to the challenges of writing and delivering working code. It was Robert Glass https://smile.amazon.com/Robert-L.-Glass/e/B000AQ4HWQ/ref=sr_tc_2_0?qid=1505480154&sr=1-2-ent -- still writing at 85! Both authors have a laundry list of funny, irreverent, timely, and horrifying dilemmas caused by the software we foist on an unsuspecting public. As Gojko notes, the real problem now is that the software is assumed to be right. That means, dear readers, that you must pay the court costs and suffer the humiliation, injury, and even death, without hope that anyone will notice or care unless you take action to defend yourself. It's sad to think that we have come to this sorry state. There is a small bright side in this fun-to-read-in-a-way book, the final chapter on steps to take to increase awareness of the errors the book described. I think this chapter should be included in academic courses and displayed on the walls of development organizations. Thank you, Gojko!
You might wonder how problems arise with computers (aka software). This book explains how, clearly and with a sense of humor. From parking tickets/fines to invalid input to my favorite, the reboot to fix a timing/memory leak problem. We program and test our systems. But, do we check for conditions that can cause failure, or worse, cascading defects?
Gojko wrote a terrific book that explains how things got that way. Even better, he has an entire chapter on what we could do about it: The Inverse Monkey Rule. If you are not sure of how you might mistake-proof your code, or create better tests, read that chapter. Yes, both developers and testers should read that chapter. If you're a manager or project manager, and you want your team to skimp on testing, read the rest of the book. Then, read that chapter. The additional testing won't take much longer and will prevent the kind of sad/funny defects Gojko explains in the rest of the book.
Read this, and sigh (if you're like me) or weep. Then, get to work.
Reviewed in the United States on December 24, 2017
Gojko cracks open the horrifying, befuddling, silly and sometimes very consequential errors we humans reign down on ourselves with computers. This book will at times make you shake your head with incredulous resignation, at other times turn the pages to learn the punch line (how did //that// happen?!) and at other times you’ll find yourself smiling at our foibles. Along the way, you stay riveted as you read these errors written as pithy stories supplemented by engaging illustrations.
From errors with names, time, postal codes, rounding, currency, bad validation rules, and more, you’ll be amazed –and saddened—by the errors we have wrought with our software. Like Robert Glass, Gojko is raising the gauntlet to software developers, testers, investors and digital product leaders to sharpen our thinking and prevent these errors from escaping into the wild.
We need to pay heed—and Gojko’s engaging book is a useful tool to help.
Reviewed in the United States on September 4, 2017
This book has many great stories about software problems that are irritating us repeatedly or driving us mad, and that are costing our society a lot of money. Which is something that we should be more aware of.
The stories make you think about things that at first look simple, but in practice aren't. Like the story on post code that differ in length, where some countries don't have them, and not all of them are numeric; in the Netherlands we actually have four digits and two characters. Think about that when you design a input form and ask the user to enter the post code and validate it before giving the error message "Post code should be five digits".
The book also provides ideas that will help you prevent problems and make software more human friendly. Thank you Gojko!
Reviewed in the United States on December 17, 2017
I’ve never laughed so much while learning so much. Gojko Adzic’s book is both essential reading and a pleasure.
Let me explain why I think this book is so important. The IT community has been learning that it must build all of its systems “ruggedly” (in the sense promoted by the Rugged Software movement) – that is, build in a way that is secure, scalable, resilient, available, flexible, and that fails gracefully, when it must fail. None of these qualities can be added after the fact, but must be built in from the beginning. As the principle has it, "I recognize that my code will be used in ways I cannot anticipate, in ways it was not designed, and for longer than it was ever intended." It is difficult for us all to learn how to do this. Adzic’s book shows us the kinds of things we must think about in order to build ruggedly, especially when we have a global user base and Internet scale. Through entertaining stories and examples, Adzic is teaching us how we must now think when we develop systems.
I am also always on the lookout for IT books that that can be read profitably by the non-IT community. I think this is one of the rare books that gives a non-IT audience some sense of the complexities faced in building software, and some insight into why and how systems fail. I would recommend this book for everyone in IT – and everyone who ever uses, touches, or relies on any software system!
Reviewed in the United States on September 24, 2017
It is easy to see why Gojko Adzic is so well respected worldwide and why he has won so many awards. He has an innate ability to explain things in a way that just makes sense. This book is a very interesting reflection on the modern world we live in and the incompatibilities between technology and humans. Our world is increasingly reliant on computers, sometimes in life and death situations. Yet computers are merely machines that interpret our instructions – and at the intersection of humans and computers lies the interpretation and assumption that so many software professionals deal with daily. This lively and interesting book is a fascinating insight into this world, filled with lessons of things that went wrong, why they went wrong and the impacts of this (which at times are very funny). I thoroughly recommend this book to anyone interested in how humans and computers interact. It is an easy and fun read that I found really refreshing.
The stories of software gone wrong are hilarious - though some are also poignant and even rather depressing. We humans don't learn very quickly from history. To me, the big value in this book is the heuristics that can help us prevent stories about the software we're delivering ending up in a book like this sometime in the future. Read it for some valuable lessons to guide your testing efforts.