Hacker News Reader

Comment by nxc18 | Hacker News Reader

I think its interesting to see real-world customers and how they use software.

Being in university, I get to see a whole range of people. You realize that people don't really have a robust mental model of how their computer works or how the software they use is structured. Then we 'computer people' wonder why they struggle with our software.

There are so many times I'll watch someone go through a laborious process to find a google doc, despite having seen a link to it on their screen at least 4 or 5 times. Or I'll see them go to the search bar, type in google, then start their search. Or go to the file menu rather than use shortcuts (every. single. time.). Or use tabs to manually center things rather than use the center button.

Even relatively advanced users will completely miss the existence of styles in Docs & Office.

And all of these are just the basics. We really do need to make software easier/more intuitive.

View on HN

I'm running out of people to do it with, but I love taking someone in the company who has never used, read about, or even seen a program and setting aside some time and just handing it to them and saying "do x".

It's such a massive help in finding what can be confusing, what requires industry knowledge, what is easy for a developer vs a user, etc... It's so often that we as developers take some knowledge for granted, and helping the user either get that knowledge, or not need it is monumentally helpful.

Sadly, I've found that once they do that, they are "tainted" and can't really do it again as well with that product, so it's something I try to do as late in the process as possible. But it has been what prompted me to throw out an entire redesign for a screen and start over very late in the process, and to good effect.

I'm seriously afraid our usability will suffer when we run out of people to do this with.

Interns are a great solution to the "running out of new, untainted eyes" problem.

-I do this from time to time to test one-off service/support docs prior to shipping them off to my customers.

(I work in the marine industry; when a customer has a problem, he's often way out on the high seas, outside of even helicopter range - so, effectively, if whatever issue he's facing cannot be solved with what he's already got on board and some detailed instructions, he's SOL.)

After breaking down the solution (hopefully, we're able to isolate the problem!), I bring all the required hardware, software, scripts and my first draft for the solution document to someone Not Into Automation & Control(tm) - say, the cafeteria or cleaning staff and ask them to work their way through it.

It never ceases to amaze me how many things we just take for granted after working in a field for a few years. ("Oh, but surely it is self-evident that..." "F--k no, it isn't!")

Result: Someone not at all involved in the day-to-day management of our products feel a much stronger attachment to the company and what we do to stay in existence; a customer gets a procedure which is so detailed, they can have anyone do it; I get to sleep well as I know the tasks sent offshore are as detailed and correct as I can possibly make them - and everybody is better off. At least I like to think so.

> Or use tabs to manually center things rather than use the center button. (...) We really do need to make software easier/more intuitive.

First thought: what if the software could guess that you're trying to use tabs to center text, and offer a hint to use the "center" button instead? Then I realized that Microsoft Office already went this way once, and we all know the result.

It's a tough thing, making people use your software well, especially if the target audience is not to be expected to actually want to learn anything.

Makes me wonder though, where does the difference between Word and e.g. Photoshop come from? Both are professional tools, but with the latter, you don't get people stuck at the most basic level and utterly clueless. They all know this is a tool and they need to learn to use it.

Word processors are professional tools, but they're also student tools, amateur tools, etc. They (and MS Word in particular) come pre-loaded on computers, given out by schools, etc. You've got a larger population with a larger range of goals trying to use them. And when someone transitions from student to professional, they're likely to continue making do with however they were using Word before.

Photoshop is a tool that you have to specifically seek out, whether that means buying it or "acquiring through other means". It's got a smaller population of professionals and hobbyists who are used to thinking of it as a tool. I think that's where the difference comes in.

How come 'we need to make this easier' is always the answer?

Why can't society shoulder some of this burden. We should be teaching people to understand computers and difficult software; the 'make it easier' answer leaves everyone worse off because software is everywhere

Why? We make products for end users, most of which are relatively trivial and not very dangerous. It's unlikely you'd ever see some kind of government mandated or built into edu education on usage like we get with cars. And that's just about the only common product I can think of where users are forced into being trained in its usage. Cars and, depending on the state, certain guns. If we make a product for untrained users that is hard for them to actually use isn't it on us?

No, we make products to do stuff. The problem with simplifying is that you take power out of the hands of those who know how to use it, by reducing the combinatoric explosion of paths through your program down to just a few easy-to-understand use-cases. In the end you get software that looks and feels like it was built for children, but is instead targeted at adults, and if that adult wants to do anything outside of the easy-to-use program's very narrow and opinionated understanding of the world, that adult is shit-out-of-luck.

In a model of software consumption where users aspire to better themselves, yes the beginner is stymied but the possibility is still there for completing the task. That's not possible in our current model -- either the program works and you use it the way the designer intended, or you're fucked.

I know it's an unpopular opinion, but I agree with your general point. The trend in the last ~10 years of simplifying UIs did a lot of good; as low an opinion as I have of Apple, they deserve a lof of credit for spearheading and popularizing this trend. But for whatever reason, people are unable to understand the concept of trade-offs and flipped from "all power, no usability" to systematically ignoring the value of "ability to do custom things with your computing devices". The mantra seems to have become: every design decision should be made in favor of the user being a perpetual neophyte, no matter what the costs to the value and capability of the system. Systems that allow for gently increasing competence create the most value for the user, but we're stuck in a shitty low-utility equilibrium where it's easier to market systems where you can do ~100% right off the bat. The rub is that this was achieved by lowering the value of 100%, not making it easier to achieve.

There's an alternative which satisfies both constraints: simplify UIs for the most common use cases while still allowing access to arbitrary amounts of capability for those who want it. There's a reason that every personal computer in my family runs on some flavor of Ubuntu: the default GNOME setup is 50x easier to use than any Windows computer[1] for people like my dad, who's a non-savvy enough user that he still struggles with copy and paste. Yet, it still allows the motivated to Google around and do things like change a single file in a theme's assets folder to make your panel transparent, something I actually did back in college when I cared more about things like themes.

[1] Note that I'm talking purely about the OS itself as an illustrative example of my point: having to be careful and buy a computer without hardware compatibility issues is a separate issue and is an actual pain in the ass that very reasonably prevents many people from following my example and switching their family to Linux. I just did it because installing Linux once every few years was a hell of a lot less work for me than debugging Windows over the phone once a week.

Agree entirely! It isn't the simplified UI itself that I lament, it's the removal of advanced possibilities. In a lot of cases, the fix is easy- just add an "Advanced" button with options for the power users

Nobody makes products to do stuff except maybe people working on open source or so on. Products are made to sell, their functionality is incidental, for as much as possible to as many people as possible. If power users are too narrow to out buy uneducated end users, which they are, there is nothing to be done. Why would there be any reversal of this?

The other commenter addressed this well, but I want to add something of an ethical dilemma to the mix.

Sure we can have schools teach people how to use PCs, but then people only know how to use certain software. If you've been taught extensively how to use Office and Windows, and that's all a computer is, then LibreOffice, docs, and Linux will be a challenge. Microsoft loves this and Apple has used it extensively in the past.

The danger for competitors is real. Office has caught up in the few features it was lacking; I've seen a resurgence in usage and very rarely see freshman using Google docs anymore (when I entered uni it was the opposite). Google relying on a dated, unintiutive interface that kids don't learn in school anymore is going to kill them if they don't react.

So don't teach them Windows and Office. Teach them software and computing concepts.

Stuff like, "most software has a menu bar, you can expect to find File, Edit, Window, and Help menus, here's what they usually mean," and so on.

Pretty much this, teaching people "Office" or "Windows" is the wrong thing to do, the goal is to give someone tools to interact with a word processor, whether that be LibreOffice, MS Word, Etherpad Lite, or another word processor.

If you teach a narrow set of skills and don't train for flexibility, your robbing the students by pigeonholing their skills into only being applicable to a segment of the market.

I agree. Skills should be transferrable.

I've seen friends who can do mail-merge in Word but cannot navigate the internet on a desktop with the ease and speed I can because they learned mail-merge in school but never bothered to browse internet on a laptop/desktop (instead they use phones all the time).

Let's transpose the difficult/easier dilemma to other areas, where you might be the newbie:

- Prepackaged food. Why should lettuce leaves be separated, cleaned and packaged in handy sizes? People should be totally okay with tearing apart heads of romaine if they want to make a salad.

- Zippers. Way back when, people fastened and unfastened buttons or laces to get their clothes on. That seemed like a reasonable burden at the time, so why didn't we just leave it like that, instead of switching to zippers?

- Highway exits and lane merges. Designing a network of roads can be difficult. How many signs alerting you to the next exit are sufficient? What if we asked everyone to pay attention to one clearly posted sign, because anything more is redundant?

I'm grateful for all the simplicity that keeps coming into my world. If grocers, clothes makers and urban planners can embrace simplicity, the software industry can, too.

None of those things were designed for the fulfillment of complex, open-ended tasks. They are simple devices, ergo using these things should be simple.

I don't want simple software because my problems are not simple. Computers need to move with me at the speed of my thoughts, and simple software simply cannot do that. Our modern world of software feels like shit-plastic Duplo blocks when I grew up building skyscrapers in Lego

What tools for building skyscrapers used to be available but no longer are? My computer still has a CLI and all the esoteric flags my heart could ever wish for.

A few areas that I feel we've lost functionality:

* MP3 players: I used to have a device with buttons that fit into my pocket that was able to locally hold my entire music library. I could control the device through my pocket without needing to look at it or hold it in my hand, it presented a filesystem with folders that I could simply drop music into (or whatever files I wanted, at the time 20/60gb in your pocket was a big deal). Since everythings' transitioned, first into library-based management and then into touch interfaces, actually using an MP3 player (or more specifically, whatever music program is on your phone) sucks so much more now

* Software used to work regardless of what happened to its creator. Desktop software still largely does. Nowadays it's almost like entrepreneurs enjoy writing emotional sunset posts, completely oblivious to all the customers they've fucked over because they suck at business

* Computer internals and abstractions were more exposed. Computing is slowly moving away from keeping users close to abstractions -- using modern software it feels like Product Managers want to erase and destroy users' concepts of things like files and folders. Cloud services would much rather you think of their software as an interface to their silos, and the kind of interoperability that you used to get for free by sticking to a 'protocol' of files and folders, is no longer there. (How hard is it to examine iOS or Android at the individual file level? How hard did it used to be?)

* I used to be able to open most software on my phone without being nagged with a popup for some reason or another. If it isn't a "HEY LOOK AT THIS NEW FEATURE YOU STUPID USER WHO NEVER EXPLORES ANYTHING" it's a "PLEASE VOTE ME FIVE STARS". Software talks too much, and I don't want to have a relationship with its creator. Leave me alone!

* I used to be able to boot up my computer (or, hell, even my Playstation!) without being bombarded with update requests. Software used to be finished, and as a program matured you could expect patches and update frequency to fall off dramatically. Our brave new world of evergreen programming means I am perpetually hassled with updates that I don't want, don't care about, and are frankly unnecessary. Sometimes those updates even remove features, sometimes even features that I am using! (How the fuck is that acceptable nowadays anyway? In what industry is it acceptable to take something away from users that they have paid for? We have compromised our standards too far!)

I so much agree with all of your points. I want to add a few thoughts.

> Since everythings' transitioned, first into library-based management and then into touch interfaces

I can forgive touch interfaces (smartphones are awesome, and a good headset will have buttons that can be used for track control), but I don't understand the whole library management thing. How on Earth did that happen? Why did iTunes-like interface win, with all that bloat and pointless misfeatures when all one needs is simple way to filter a list of your music files and group them in logical playlists?

Moreover though, in the better days, you controlled your music. It was made of discrete data files. The modern way is all cloud bullshit you have to stream over the Internet every time you want to listen to it.

> Computing is slowly moving away from keeping users close to abstractions

This is huge, IMO. The "low-level" abstractions of files and folders are good, because that's the level software operates on. All those attempts at abstracting files away only lead to your system actually lying to you about how the data is structured, and this can be confusing to people because different software now tells different lies, and they don't add up to a coherent whole.

  > This is huge, IMO. The "low-level" abstractions of files and folders are good, because that's the level software operates on. All those attempts at abstracting files away only lead to your system actually lying to you about how the data is structured, and this can be confusing to people because different software now tells different lies, and they don't add up to a coherent whole.

I honestly feel that the only reason this happens is so that business-people can insert more "value-add" into the equation

I feel things would be much better if business-oriented people asked what value something adds for their user, instead of "value-add" being a code word for "more money for us".

I call this productification. "Can this feature be made into a product?"

Ah, your word processor can count words. Can we sell a separate product that counts words in documents? Ah, your network interface can be taken up or down. Can we sell a Network Management Product?

> I used to have a device with buttons that fit into my pocket that was able to locally hold my entire music library. I could control the device through my pocket without needing to look at it or hold it in my hand

Companies still make standalone MP3 players that use dropped-in files and dedicated button controls. In fact, they're cheaper and more available than ever. https://www.amazon.com/Sandisk-8GB-Clip-Player-Black/dp/B00V...

> How hard is it to examine iOS or Android at the individual file level? How hard did it used to be?

It's easier than it used to be, as iCloud on iOS effectively added a shared file system that didn't originally exist.

Actually, these aren't simple devices at all. Good food-sorting machines can cost $30,000 or more. They are loaded up with optical sensors, intelligent paddle ejectors and other goodies. Lots of software in them, too! Distinguishing between a "good" and "bad" leaf of lettuce at feed rates of 3,000 pieces a minute is a lot harder than it sounds.

They succeed in the market because they make complex tasks seem simple. Sorry about the Duplo feeling, and it's a familiar lament of craftspeople everywhere. But we aren't going back to the days of artisans trimming lettuce heads one at a time. Too slow; too costly.

Yeah but the use-case for a food sorter is to sort food (specifically, separating heads of lettuce at scale), and that's all.

It's a very UNIX-like machine.

> Prepackaged food. Why should lettuce leaves be separated, cleaned and packaged in handy sizes? People should be totally okay with tearing apart heads of romaine if they want to make a salad.

Tangent, but: prepackaged food irks me. So you pack lettuce leaves in nice small plastic bags, or wrap each cheese slice in a piece of paper and put ten of them in a plastic box - basically creating a humongous amount of plastic waste, all because people can't be bothered to use a cheese cutter or pick the lettuce with their hands, and express this as market preference.

> Highway exits and lane merges. (...)

I like to point at cars as something that somewhat got this right. We're not letting a person to enter the car first time in their life and go driving on public roads immediately. Everyone understands that a car is a tool and needs appropriate training to use. People are willing to spend 30+ hours on driving lessons without blinking, because this is obvious - it is expected by society.

I think we could use a bit of this expectation in software industry too. A lot of software is "unintuitive" only because the user couldn't be bothered to spend 30 seconds thinking about what's on the screen, not to mention using the "help" menu or reading a manual. We can keep dumbing down our software, but there's a trade-off - beyond some point, the only way you can make something easier to use is by removing its essential features. There's no amount of modern UX and Angular code that can make a CAD tool or an accounting package masterable in 30 seconds.

Difficult-to-use software is most often the fault of bad design - and "software is everywhere" is precisely the reason we should care about making things easier and more accessible. The dozens or hundreds of engineering hours to revamp a feature or a set of controls could save tens of thousands of user hours over the lifetime of the software (especially if you have a significant number of useres).

And gives you a leg up on the competition.

For some cases of software I agree with you, my IDE should not be made less powerful just to make it easier to master, however even so it should be built up logically - e.g if editor settings are in one place, the option for which font to use should not be elsewhere. If the shortcut key to rename is ctrl+r r, the shortcut key to inline is ctrl+r i and the shortcut key to add a new method is ctrl+shift+m then that is a bad design.

Most software should aim for simplicity though, I am interested in using your software to pay my bills then get back to reddit, I don't want to learn a complex system.

> Most software should aim for simplicity though, I am interested in using your software to pay my bills then get back to reddit, I don't want to learn a complex system.

Software complexity should match the complexity of the problem space. The problem today is that the trend is to make oversimplified software. I guess it's fine if it lets you pay your bills, but maybe a little more complex software would let you earn more money to pay those bills with, by expanding the amount or complexity of things you're able to do.

Reply on news.ycombinator.com