Humans vs Computers is a book about people caught between wrong assumptions and computer bugs. You'll read about humans who are invisible to computers, how a default password once caused a zombie apocalypse and why airlines sometimes give away free tickets. This is also a book on how to prevent, avoid and reduce the impact of such problems.
Our lives are increasingly tracked, monitored and categorised by software, driving a flood of information into the vast sea of big data. In this brave new world, humans can't cope with information overload. Governments and companies alike rely on computers to automatically detect fraud, predict behaviour and enforce laws. Inflexible automatons, barely smarter than a fridge, now make life-changing decisions. Clever marketing tricks us into believing that phones, TV sets and even cars are somehow smart. Yet all those computer systems were created by people - people who are well-meaning but fallible and biased, clever but forgetful, and who have grand plans but are pressed for time. Digitising a piece of work doesn't mean there will be no mistakes, but instead guarantees that when mistakes happen, they'll run at a massive scale.
The next time you bang your head against a digital wall, the stories in this book will help you understand better what's going on and show you where to look for problems. If nothing else, when it seems as if you're under a black-magic spell, these stories will at least allow you to see the lighter side of the binary chaos.
For people involved in software delivery, this book will help you find more empathy for people suffering from our mistakes, and discover heuristics to use during analysis, development or testing to make your software less error prone. <
Gojko Adzic is a partner at Neuri Consulting LLP, winner of the 2016 European Software Testing Outstanding Achievement Award, and the 2011 Most Influential Agile Testing Professional Award. Gojko's book Specification by Example won the Jolt Award for the best book of 2012, and his blog won the UK Agile Award for the best online publication in 2010.
Gojko is a frequent keynote speaker at leading software development conferences and one of the authors of MindMup and Claudia.js.
As a consultant, Gojko has helped companies around the world improve their software delivery, from some of the largest financial institutions to small innovative startups.
First of all, this books reminds me one of my fav software conf talks - it was DevDay 2014 (I think) & the speaker was Jon Skeet. The topic was mainly about the conceptual gaps between the real world & deceptively simple models we use to implement it in our applications. Basically, this book is like Jon's talk on hyper-steroids: several times longer, several times more comprehensive & just as enjoyable.
So, just to be precise - if you've read previous Gojko's books, this one is nothing like them -> different convention, different topic. Which is good, at least IMHO.
What you can expect when starting to read? Very well investigated & documented history of ... fuck-ups :) Not just random ones, but ones that were caused by oversimplifications, insufficient research, surprising border cases, etc. Hats off to Gojko for gathering such great material.
What would be the benefit of reading this book? Clearly it's not only about entertainment, but there's no simple, single lesson to be taught. In my case - it's very well aligned with my thoughts regarding where software engineering (as an industry) is heading: writing code gets easier & easier, threshold to create something gets lower & lower, but the consequences of breaking things get more & more serious. Author doesn't answer what we can do, doesn't propose anything that could deal with the issue (for now & in future), but even increasing the overall awareness seems like a great justification for a book like that.
This book contains a collection of stories about software defects (AKA bugs). While I'm a programmer myself, they seem to be written with a broader audience in mind. I don't think that you have to understand technical intricacies in order to be able to follow the stories.
While I was reading, I was wondering whether my (doctor) wife would be able to understand the book. Perhaps, but I'd guess it's just so technically detailed that she'd tune out on it. On the other hand, I'd think that anyone who works professionally with software development should be able to understand and learn from it. Developers, managers, testers, designers, operators, etc.
The stories are light reads, but their messages still carry weight. Lots of things can go wrong when software executes in situations it wasn't designed for, and they're not only stories of lazy or incompetent developers. There are some stories where I think I wouldn't have been able to predict the defect either.
For programmers, the book is a good reminder that the assumptions we make could easily turn out to be wrong, and that that can have real consequences for real people.
From an aesthetic viewpoint, I find the typesetting and the illustrations slightly distracting. Chapter titles and illustrations are comics-like, and while I don't mind comics (I have quite a collection!), it makes the book look like toilet litterature, and I think that's a shame; it deserves to be taken more seriously than that.
Fantastic collection of a wast amount of possible programming fuckups. A must read for every developer. Find out how small and funny but also huge and catastrophic bugs cause people to loose time, money or even die.
It was very entertaining. A good book for reading during family vacation. It contains several stories about the interaction between humans and computer (systems). A lot of wisdom can be gained about whether something should be automated or how it should be automated.
Odlicne price koje na sjajan nacin pokazuju sta se desava kada racunari odbiju da "slusaju", ili kako ljudske greske i nedovoljno istestiran softver moze da napravi ogromne probleme koje kostaju milione i milijarde.
Here's a beautiful combination of practical tips for good product development and really funny stories to make you lol. For that final touch of delight we don't demand but we find so pleasing, you also have great and abundant illustrations that add nice comical value. I enjoyed reading this book very much and I'm giving it a solid 5* rating.
In a nutshell, this is a book about missed requirements, or ones where the creator did not think everything through. Digital systems are often expected to communicate between each other, but that's rarely considered during their creation - mainly because it's hard to predict what applications users will find of the system later, or what other software will be invented after you release yours. Or... how even the best designed systems can't resist when the idiosyncrasies of real life stand against it.
Take the simplest example of name validations. Product & tech people put them in place to prevent fake data entry, however their good intentions end up causing tons of frustration for people with a first name that contains 1 single letter. Or 101 lol.
The names thing escalate when systems assume that names containing "Test"or "Sample" are bound to be test users and refuses to take them seriously. Other dangerous assumption computers make is that "Null" or "Void" means no value. The danger escalates when one system does the assumption and passes the case to another, which in turn finds it perfectly normal to issue a parting ticket to the car with plates "VOID"...
From names to addresses, from automation gone wrong to randomness being not so random, from buying -1 books on Amazon to naming your child Facebook, and from breaking computers by resetting their date to before 1 Jan 1970 to breaking iPhones by trying to send rainbows and flags emojis... This book will tell you a bunch of funny yet instructive stories on how we feel we are the masters of the world and yet we set ourselves for failure all the time when it comes to tech.
The longest 200 pages that I read in a while. Books is constructed in a very repetitive way, presenting stories and chopping them into paragraphs. It looks almost like it was glued from different pieces. I admit that I truly admire the author as an IT professional. In this book I found nothing from him. It's a generic book about humans' mistakes related to computers. No human touch included.
Topics covered in this book: null, address, dates and a few others. All the things that usually make IT's heads hurt.
On the positive note, the amount of gathered data is quite impressive. You can tell it by reviewing all the sources at the end of the book. This is the only reason why I didn't give it 1/5.
A must read for every software developer. Automation helps to get things done faster, not better. Gojko explains all the different ways how automation can go wrong and what consequences this may have. Trivial things like names offer endless opportunities for big failures, the same is for error conditions, test data and many other parts we never think about. Before you automate your next task, read this book and stop yourself from becoming part of the next edition.
Readable and enjoyable short stories on how software behaves in unexpected and unwanted ways. Moreover, Gojko suggests how these bug, flaws and glitches may be avoided. Great holiday read for developers, testers, product owners/managers, project managers, business analysts and auditors.
Was doubting between a 2 and a 3 star rating. Although the stories are entertaining and the book is well written, I have the feeling this could've just been a blog post. The stories become monotonous and more of the same after a while.