What is Reddit's opinion of The Design of Everyday Things?

From 3.5 billion Reddit comments

I would strongly recommend working through the interface guidelines for Android and iOS there are lots of good UX principles in there even for web development. For more general design theory read The Design of Everyday Things .

The design of everyday things

Its what im reading while i procrastinate on "thinking fast and low"

It delves into the psychology of how we interact with everyday things. While not dedicated to biases there are cases in the book where certain designs have the ability to trigger autopilot responses ie biases.

Its given me a new insight on how humans interact with an interface and how to structure for it

Your brain is essentially a giant complex pattern-matching heuristic guessing machine. It looks at something and decides "yep that probably is a sabre-tooth tiger holy shit" or in this case "that is a boxy looking thing with a hole at the top, let me rummage through my list of known boxy shapes with holes, oh yeah that's probably a ______." This is how people can operate on autopilot performing actions without thinking consciously, which is why someone whose washing machine is near the bathroom may experience an odd urge to throw their clothes in the toilet if they are carrying their clothes and see an open toilet first -- "round hole with a lid sticking up, yep that's where the clothes go."

When drunk the neurons still fire but the brain has trouble making a thorough analysis so you are more on autopilot than when not drunk, so more likely to make errors like this. So when you need a toilet anything remotely roundish/boxy looking with some kind of hole on the top looks like a reasonable place to go -- laundry baskets, trash cans, etc.

It's really just a case of mistaken identity.

Source: The Design of Everyday Things by cognitive scientist Donald Norman. Amazing book, will change the way you look at everything.

TL;DR of the book: fuck doorknob designers right to hell.

If you can afford it, take a class or two at a proper art school. They can really help teach the design process. Also, read! This applies to everything design. https://www.amazon.com/Design-Everyday-Things-Donald-Norman/dp/1452654123

And it's a good jumping off point.

The arguments for and against can be summarized with 2 simple points:

1. In the real (developed) world, the rule of law takes strict priority over brute force. Laws are developed in such a fashion that they follow the intent of the majority so long as they do not clearly violate the rights of the minority or of individuals. There is no question of what a judge or jury in nearly any developed country would rule in this case.
2. In situations without trust and without a trustworthy authority, a robustly built and well-tested system will not need a justice system to enforce the rule of law. For example, vending machines are designed not to need a cashier and ATM's are designed not to need a security guard.

The reality is, Ethereum is not a robustly built and well-tested system, and neither is the Dao. Yes yes yes, this wasn't ethereum's bug, blah blah blah. That's irrelevant - Robust & well designed systems prevent failures by proper and clever design.

This isn't to shame or bash Ethereum. Ethereum is barely 2 years old. The internet took nearly 25 years to develop. It took 22 years to go from Unix to Linux. It took 20 years to go from public key cryptography to a usable SSL encryption system. It took 18 years to go from the development of a mouse to a widely usable graphical OS, and 5 more to reach something non-geeks could use.

In conclusion, Ethereum age 2 is not a robustly built and well tested system. It does not create a bad precedent to acknowledge this reality and apply the rule of law until Ethereum grows up. When Ethereum has grown up, miners will refuse to accept arbitrary transaction controls, which is why the Blockchain innovation works so well.

I don't mind the phrase if it's true. But this looks as abstract as any other web framework. Only humans willing to get over the learning curve will use it.

My suggestion for anyone who wants to program for humans is to read The Design of Everyday Things.

I just read The Design of Everyday things and recommend it to anyone interested in how fucking retarded designers can be.

EDIT: Ha, I posted this link before I finished watching the video, how apropos.

I actually do design things for a living, although not board games. I design medical devices and I guess there are more devices out there that I designed than there are Pandemic board games.

That's kind of irrelevant though, because design is best judged by naive users, not by design experts. When a device has a common stumbling block, that is considered a design risk, and in the case of medical devices it is not considered acceptable by regulatory agencies to mitigate that risk through the instruction.

A good design from my field is one where the operation is so intuitive that instructions are minimal or not necessary at all.

Board games are awesome for people with an interest in design because they take a lot of risks and even the best and most successful games have areas in which they have failed. If you aren't completely discouraged by this conversation and have any interest in design I highly recommend <em>The Design of Everday Things</em>. It's used by everyone from medical device designers to web developers.

That seems like the subject of this book:

The design of every day things.

The human brain has a few predictable characteristics that you can exploit to design better products. For example, if you make a part symetrical, the cover plate for it will sometimes be installed backwards. You can fix that so it only goes on the right way and no other way.

1) Read more professional code. There are tons of open source javascript libraries. Even downloading node.js and reading the source would be a good idea.

2) Write more. Don't worry too much about 'the right way' at first. The more you write, the more you will get an intuitive understanding on why some ways work better in some situations, and some ways will lead to a complete disaster. Writing code is also a great way to read more code, since you'll inevitably need to look stuff up.

3) Read programming blogs.

4) For javascript, focus on the similarities/differences between libraries eg. why would a developer favor angular.js over backbone.js? why wouldn't they?

5) If UI is where you want to specialize in, you should read up on user experience and usability. http://www.amazon.com/Design-Everyday-Things-Donald-Norman/dp/1452654123 is a good non-technical place to start.

Two that spring to mind are:

1. <em>The Design of Everyday Things</em> by Donald A. Norman; and
2. <em>Don't Make Me Think: A Common Sense Approach to Web Usability</em> by Steve Krug

They're not explicitly about game design but if you want to learn about UX it's important to look at it from the top down. Everything you learn about UX can be applied to any interaction from/to a person.

There're also some good articles to be found on the Nielson Norman Group website. It can be a quagmire of information you're not interested in but you'll find data and findings from research papers on UX, plus some general summaries that can be good to bookmark and check on whenever you design something.

As for general advice, look up Fitts Law and Hick's Law. Both of those on their own can go a long way. There's a nice simple website for learning more about UX laws called (funnily enough) Laws of UX.

Anyways, I hope you find those links useful, I love UX and get excited to see people take it seriously!

https://www.amazon.com/Design-Everyday-Things-Donald-Norman/dp/1452654123

Und hier sein Buch, sehr empfehlenswert.

Check out, The Design of Everyday Things by Donald Norman. He does a whole section on refrigerator interfaces being horrible. Rest of the book is great as well.

Because compiler-driven operator fusion is mostly useless. Example:

def range(n: Int): Future[Seq[Int]] = Future(0 until n)

def evens(f: Future[Seq[Int]]): Future[Seq[Int]] = f.map(.filter( % 2 == 0))

// later ... var ref1 = range(1000)

// later ... var ref2 = evens(ref1)

// later ... val ref3 = ref2.map(_.sum)

I can guarantee you that the compiler can't optimize this example. Even if it can smell the code being invoked, it cannot ensure correctness. "Whole program optimizations" don't help either. For the same reason that OOP subtyping and Hindley–Milner type inference don't mix well.

The only instance where this will be useful would be when doing stuff in the same expression or block of code, again, because that's when the compiler can prove correctness:

Future(0 until n).map(.filter( % 2 == 0)).map(_.sum)

And even this I dislike very much. For one, because I can do such optimizations myself easily, no compiler tricks needed. But more importantly, a design lesson which I learned from The Design of Everyday Things is that the user needs to build a good mental model for how stuff works.

And you know, strict stuff is strict and by rewriting expressions you basically assume that there are no side-effects involved. Again, we are on top of the JVM and the compiler cannot prove that. And if there are side-effects involved, it means you don't have referential transparency, in which case by having the compiler rewrite that expression you'll get a visible and very confusing difference of behavior. An interesting take on this is what Erik Meijer expressed in his The Curse of the Excluded Middle (Mostly functional programming does not work) article.

And that's pretty bad from a design point of view actually. I expressed this opinion to Dmitry Petrashko, a Dotty engineer that presented what he was working on at last year's flatMap(Oslo) / Typelevel Summit - I happened to be in the same room with a bunch of gods and couldn't help expressing my opinion as I usually do ��

You see, the main use-cases proposed by Dmitry involved protecting people from doing dangerous stuff, like rewriting collection.size == 0 to collection.isEmpty. And it is my opinion that this is the job of an IDE or SBT plugin, not the job of the compiler, because otherwise WYSIWYG is broken, which leads to pain - not only because the code ends up behaving in unexpected ways, but also because you're denying proper education for your users and then they get burned in situations where the compiler cannot help, which is most of the time.

I hope this answers your question.

I still don't think you're fully getting where I'm coming from.

I want the web-dev eqiuvalent of this: https://www.amazon.com/Design-Everyday-Things-Donald-Norman/dp/1452654123

True - it's about <em>Design of Everyday Things</em> design. Definitely not another Silicon Valley circlejerk.

I can recommend this book! Read it twice, really good examples.

https://www.amazon.de/Design-Everyday-Things-Donald-Norman/dp/1452654123

If you want a good resource for design and usability check out this book http://www.amazon.com/Design-Everyday-Things-Donald-Norman/dp/1452654123

> it's reassuring to know that you're validating (heh) Blizzard's decisions

Well, I validate the reasoning. I do think deck slots should have been changed sooner, especially if the final decision was just to increase them.

I think they wanted to tie deckslots to the larger overhaul of the new player experience (with basic decks), the deck recipes and the collection manager changes. I feel that is a mistake, seeing how strongly the community felt about deck slots.

There's a lot to learn from this, in terms of more reactivity to QOL changes. This patch in particular was way off their usual schedule. You can see the patch graph here:

https://github.com/HearthSim/hs-data/graphs/commit-activity

The february tick was a reverted patch that didn't go live, so the gap is even larger than it looks at first glance. Tying a bunch of QOL changes to such a late patch isn't a great idea either.

Anyway yeah. They do put a massive amount of thought on this behind the scenes. Derek Sakamoto gave a talk at last year's GDC about UI, it's worth watching if you're interested. /u/bbrode also talked about deck slots in his latest stream (vod on twitch.tv/bbrode).

If you're interested in UX, I recommend the book The Design of Everyday Things (I'll PM you a PDF if you want it but can't afford it). It will open your eyes to how a lot of people don't put any thought into what they present to their users. Has a lot of applications in UI design (or HCI in general) - when you waste your users' time, you lose customers.

Fun thing to do if you're bored: Try buying Final Fantasy XIV and time how long it takes you until you enter your card #. Then do the same thing with World of Warcraft. Took me ~45 minutes for FFXIV, vs. ~5 minutes for WoW. Blizzard doesn't fuck around.

You must read this book: http://www.amazon.com/Design-Everyday-Things-Donald-Norman/dp/1452654123

But there was a penultimate awesome ending to Shadow of The Colossus...

PS. I solved the elephant. I remarked that it was stupid design. Perhaps you should take some time and read a classic: https://www.amazon.com/Design-Everyday-Things-Donald-Norman/dp/1452654123

My confusion was most certainly NOT my fault, and I resent the implication.

"When you have trouble with things—whether it's figuring out whether to push or pull a door or the arbitrary vagaries of the modern computer and electronics industries—it's not your fault. Don't blame yourself: blame the designer."