LindenRyuujin
http://gameplaying.info/wp-content/uploads/2016/05/overwatch... From this image I have no idea who is on what side in this battle. The sniper blends into her spot as she is a similar colour scheme to the metal work. Where will the car move next if it is being escorted? There is so much going on it takes a lot of knowledge to understand what is happening.
http://i.imgur.com/l3pCIgk.jpg Here on the other hand it is obvious what team everyone is part of. All character pop out as they are very different to the background (colour and shape wise). The track shows where the payload is going and where it will roll back.
TF2 has great visual clarity, it gives you information clearly without having to explain it to you. Obviously for many the lack of visual clarity in Overwatch is not a problem - which is fine, but Blizzard made a choice which is not without cost.
As for the a payload line, it definitely wasn't there in beta, it's possible they've added one, but this video from a few weeks ago suggests they have not. https://www.youtube.com/watch?v=CiAitNchwYM
Overwatch is very pretty (both games are in my opinion), however it is so busy. There are no visual cues in the design - characters and scenery share the same palette, important elements (like payloads, turrets, etc) don't stand out. No way of knowing where the important flow points are other than to play the game a lot (no indication of where the playload will go). Having had such a great example in TF2 that did all this so well it was just sad trying to get to grips with Overwatch.
League of Legends on the other hand had an amazing visual update a year or two ago and they explicitly addressed all these kind of issues. Making sure the map doesn't distract from the important in game information.
Both games have a lot of characters and a lot of knowledge burden for the players, so anything they can pull off the player makes a big difference when first starting.
From the article:
> What happened?
> Well, turns out that the person that actually owned the [email protected] was a kid that was curious and clicked the email from TheService asking him to verify his email address.
> He himself forgot about this until a couple of years later when he heard about TheWebsite from some friends, and decided to try it. He tried to create an account and got an “account already exists” error. He used the password reset functionality and that’s that. He now owns the original John Smith’s account.
I like KeePass2 which is open source but nothing like as smooth as LastPass (No browser integration on OSX and integration on firefox for windows works but isn't perfect).
You make a change, start running tests to make sure nothing is broken. It's the end of Friday and you don't finish the testing. You close everything down and on Monday you forget you had a last few tests still to complete. You pass the change into your build process and it makes it into a release. You didn't follow the process… not because you maliciously decided to skip testing, it was simply a human mistake (slightly different to your comment, but let's be charitable and assume most people aren't purposefully breaking things).
Does tracing the problem and firing you stop it happening again? Does it even stop you from making the same kind of error again in ten years time when memory has dimmed? In the end you've lost your job and your company has lost someone who probably did good work for many years (and would no doubt continue to do so in the future) over a single easily made mistake (however big the fallout from that mistake). You're also much more likely to try and bury your mistake if you know it will cost you your job.
On the other hand what about adding a step to your build process where a second person runs the testing while they review your code? No one gets sacked, everyone learns something and the chances of this happening to anyone else are massively reduced. Is the person who made an understandable mistake any more to blame than the manager who oversees the process as a whole? They allowed flaws in the process that meant your mistake could get into a release. It’s rarely as simple as one person making a mistake.
I'm simplifying of course, if your build process is anything like ours there are multiple levels this would be caught at... which is kind of the point. In our development process there are four places this error would be caught before it made it to an official release. If our release goes wrong the worst that happens is we annoy the people using the software, yet we've built up a (reasonably) robust process in exactly the way described in the article.
It’s as the article says: When a space shuttle crashes or an oil tanker leaks, our instinct is to look for a single, “root” cause. This often leads us to the operator: the person who triggered the disaster by pulling the wrong lever or entering the wrong line of code. But the operator is at the end of a long chain of decisions, some of them taken that day, some taken long in the past, all contributing to the accident; like achievements, accidents are a team effort.