While I agree that people generally feel better by getting something with little effort, I think that there is a longer-term disservice here.

Once upon a time, it used to be understood that repeated use of a tool would gradually make you better at it - while starting with the basics, you would gradually explore, try more features and gradually become a power user. Many applications would have a "tip of the day" mechanism that encouraged users to learn more each time. But then this "Don't Make me Think" book and mentality[0] started catching on, and we stopped expecting people to learn about the stuff that they're using daily.

We have a high percentage of "digital natives" kids, now reaching adulthood without knowing what a file is [1] or how to type on a keyboard [2]. Attention spans are falling rapidly, and even the median time in front of a particular screen before switching tasks is apparently down from 2.5 minutes in 2004 to 40 seconds in 2023 [3] (I shudder to think what it is now). We as a civilization have been gradually offloading all of our technical competency and agency onto software.

This is of course leading directly to agentic AI, where we (myself included) convince ourselves that the AI is allowing us to work at a higher level, deciding the 'what', while the computer takes care of the 'how' for us, but of course there's no clear delineation between the 'what' and 'how', there's just a ladder of abstraction, and as we offload more and more into software, the only 'what' we'll have left is "keep me fed and entertained".

We are rapidly rolling towards the world of Wall-E, and at this pace, we might live to see the day of AIs asking themselves "can humans think?".

[0] https://en.wikipedia.org/wiki/Don%27t_Make_Me_Think

[1] https://futurism.com/the-byte/gen-z-kids-file-systems , https://news.ycombinator.com/item?id=30253526

[2] https://www.wsj.com/lifestyle/gen-z-typing-computers-keyboar... , https://news.ycombinator.com/item?id=41402434

[3] https://www.apa.org/news/podcasts/speaking-of-psychology/att...

That’s very much dependent on the author correctly judging what should go there though

For those of you thinking (which 20%) following that article from the other day — this is where a good product sense and knowing which 80% of people you want to use it first. You could either tack on more stuff from there to appeal to the rest of the 20% of people, or you could launch another app/product/brand that appeals to another 80% of people. (e.g. shampoo for men, pens for women /s)

Q: Why does God allow so much suffering?

A: What? There is no God. We invented him.

Q: Doesn't this mean life has no purpose?

A: Create your own purpose. Eliminate the middleman.

Q: But doesn't atheism allow evil people free rein?

A: No, it's religion that does that. A religious evil person can always claim God either granted him permission or forgave him after the fact. And he won't be contradicted by God, since ... but we already covered that.

Hmm. If it works for HandBrake, it might work for life.

For example, I'd love Gimp to have a Basic mode that would hide everything except the basic tools like Crop and Brush. Like basic mspaint.

It's been hard pushing back and saying no to all the new features. We've started work on a plugin API so that people can add features and opt in to the complexity.

So I'd like to welcome the author to make more apps based on FOSS.

Dunno why people assume that FOSS developers are just dummies lacking insight but otherwise champing at the bit to provide the same refinement and same customer service experience as the "open source" projects that are really just loss leaders of some commercial entity.

Which kind of fulfills the best of both worlds: Welcoming for beginners, but full-powered for advanced users.

More software should be designed this way.

Being super simple ducks the problem.

Maybe handbrake was never meant to be used by people who need the one button solution? That one button solution exists all over the place.

It has nothing to do with free vs not-free

In addition to this issue, I've also had good conversations with a business owner about why he chose a Windows architecture for his company. Paying money to the company created a situation where the company had a "skin-in-the-game" reason to offer support (especially back when he founded the company, because Microsoft was smaller at the time). He likes being able to trust that the people who build the architecture he relies on for his livelihood won't just get bored and wander off and will be responsive to specific concerns about the product, and he never had the perception that he could rely on that with free software.

using the remote analogy, the taped versions are useful for (many!) specific people, but shipping the remote in that configuration makes no sense

i think normal people don't want to install an app for every specific task either

maybe a solution can look like a simple interface (with good defaults!!) but with an 'advanced mode' that gives you more options... though i can't say i've seen a good example of this, so it might be fundamentally flawed as well

I wanted to write an article or short blog post about how Windows 10, menus and javascript, increasingly tuck away important tools/buttons in little folds. This was many months ago.

I want to write it and title it, "What the tuck?" But tuck refers exactly to the kind of hidden menus that make those so called sleek and simple UIs for the the 80% of users.

The problem is that it stupefies computing literacy, especially mobile web versions.

Perhaps not every casual web browser needs to sit at a desk to learn website navigation. Then again, they may never learn anything productive on their own.

These kind of ui are extremely hard to make.

True but with a caveat: Those people rarely need the same 20% of your features.

My criticism of Free Software is exactly the reverse. There isn't enough of that kind of stuff on Linux!

Though to be sure, the Mac category (It Has One Button) is even more underserved there, and I agree that there should be more! Heck, most of the stuff I've made for myself has one button. Do one thing and do it well! :)

Handbrake is only popular _because_ it is so powerful, not in spite of it.

And IMO, Handbreak is more complicated than CLI ffmpeg. It's really chaotic.

I am in favour of simplified apps like this, maybe it can be a simple toggle switch in the top right corner between simple and advanced. Similar to that stupid new version of outlook I have to constantly switch back to the old version.

Yes, but those 80% all use a different subset of the 20% of features. So if you want to make them all happy, you need to implement 100% of the features.

I see the pattern so often. There is a "needlessly complicated" product. Someone thinks we can make it simpler, we rewrite it/refactor the UI. Super clean and everything. But user X really needs that one feature! Oh and maybe lets implement Y. A few years down the line you are back to having a "needlessly complicated" product.

If you think it could easily be done better, you don't understand the problem domain well enough yet. Real simplicity looks easy but is hard to achieve.

Maybe we should just say free software is amazing and not a tool for home users, in order to get home users to use it.

BTW, if all you can do it drag-and-drop a file, do you need the "convert" button?

Grab an LLM and make a nice single button app they can use.

LLMs writing code, plus free software, a match made in heaven.

It’s also a new take on Unix “do one thing well” philosophy.

Seems like a win-win, take my money solution, for some reason the market (and I guess that means investors) are not pursuing this as a consumer service?

Why? The same kind of people who find Handbrake intimidating also find the concept of files and juggling multiple applications intimidating.

The disaster that is "modern UX" is serving no one. Infantilizing computer users needs to stop.

Computer users hate it - everything changes all the time for the worse, everything gets hidden by more and more layers until it just goes away entirely and you're left with just having to suck it up.

"Normal people" don't even have computers anymore, some don't even have laptops, they have tablets and phones, and they don't use computer programs, they use "apps".

What we effectively get is:

- For current computer users: A downward spiral of everything sucking more with each new update.

- For potential new computer users: A decreasing incentive to use computers "Computers don't really seem to offer anything I can't do on my phone, and if I need a bigger screen I'll use my tablet with a BT keyboard"

- For the so-called "normal people" the article references (I believe the article is really both patronizing and infantalizing the average person), there they're effectively people who don't want to use computers, they don't want to know how stuff works, what stuff is, or what stuff can become, they have a problem they cannot put into words and they want to not have the problem because the moving images of the cat should be on the place with the red thing. - They use their phones, their tablets, and their apps, their meager and unmotivated desire to do something beyond what their little black mirror allow them is so week that any obstacle, any, even the "just make it work" button, is going to be more effort than they're willing (not capable of, but willing) to spend.

Thing is, regardless of particular domain, doing something in any domain requires some set of understanding and knowledge of the stuff you're going to be working with. "No, I just want to edit video, I don't want to know what a codec is" well, the medium is a part of the fucking message! NOTHING you do where you work with anything at all allows you to work with your subject without any understanding at all of what makes up that subject. You want to tell stories, but you don't want to learn how to speak, you want to write books, but you don't want to learn how to type, write or spell ? Yes, you can -dictate- it, which is, in effect, getting someone competent to do the thing for you.. You want to be a painter, but you don't care about canvas, brushes, techniques, or the differences between oil, acrylic and aquarelle, or colors or composition, just want to make picture look good? You go hire a fucking painter, you don't go whining about how painting is inherently harder than it ought to be and how it's elitist that they don't just sell a brush that makes a nice painting. (Well, it _IS_ elitist, most people would be perfectly satisfied with just ONE brush, and it should be as wide as the canvas, and it should be pre-soaked in BLUE color, come on, don't be so hard on those poor people, they just want to create something, they shouldn't have to deal with all your elitist artist crap!) yeah, buy a fucking poster!

I'm getting so sick and tired of this constant attack on the stuff _I_ use every day, the stuff _I_ live and breathe, and see it degenerated to satisfy people who don't care, and never will.. I'm pissed, because, _I_ like computers, I like computing, and I like to get to know how the stuff works, _ONCE_ and gain a deep knowledge of it, so it fits like an old glove, and I can find my way around, and then they go fuck it over, time and time again, because someone who does not want to, and never will want to, use computers, thinks it's too hard..

Yeah, I really enjoy _LISTENING_ to music, I couldn't produce a melody if my life depended on it (believe me, I've tried, and it's _NOT_ for lack of amazingly good software), it's because I suck at it, and I'm clearly not willing to invest what it takes to achieve that particular goal.. because, I like to listen to music, I am a consumer of it, not a producer, and that's not because guitars are too hard to play, it's because I'm incompetent at playing them, and my desire to play them is vastly less than my desire to listen to them.

Who are most software written for? - People who hate computers and software.

What's common about most software? - It kind of sucks more and more.

There's a reason some of the very best software on the planet is development tools, compilers, text editors, debuggers.. It's because that software is made by people who actually like using computers, and software, _FOR_ people who actually like using computers and software...

Imagine if we made cars for people who HATE to drive, made instruments for people who don't want to learn how to play.. Wrote books for people who don't want to read, and movies for people who hate watching movies. Any reason to think it's a reasonable idea to do that? Any reason to think that's how we get nice cars, beautiful instruments, interesting books and great movies ?

Fuck it. Just go pair your toaster with your "app" whatever seems particularity important.

Not 5 minutes after that someone else on the comments went on a weird rant about how allegedly Inkscape and all FOSS was "communist" and "sucked" and capitalist propietary stuff was "superior".

In this particular case I'd just tell people to download and use VLC Player. But I get the point.

Concise

Focus only on the parts that are really needed, necessary, or the most important; hide the currently unnecessary or secondary, or simply remove the truly unnecessary and secondary; remove all unnecessary

Maybe it can help you

It also opens up opportunities for money-making, and employment in Free Software for people who do not program. The kind of hand-holding that some people prefer or need in UX is not easy to design, and the kind of marketing that leads people to the product is really the beginning of that process.

Nobody normal cares that it's a thin layer over the top of a bunch of copyleft that they wouldn't understand anyway (plenty of commercial software is a thin layer over permissively licensed stuff.) Most people I know barely know what files and directories are, and the idea of trying to learn fills them with an anxiety akin to math-phobia. Some (most?) people get a lot of anxiety about being called stupid, and they avoid the things that caused it to happen.

They do want privacy and the ownership of their own devices as much as everyone else however, they just don't know how much they're giving up when they do a particular software thing, or (like all of us) know that it is seriously difficult if not possible to avoid the danger.

Give people mock EULAs to click through, but they will enumerate the software's obligations to them, not their obligations to the software. Help them remain as ignorant as they want about how everything works, other than emphasizing the assurances that the GPL gives them.

The difficult interface was a good filter.

The majority of users probably want the same small subset of features from a program and the rest are just confusing noise.

Whereas I think they are in fact describing 'average' people.

I suspect most HNers self-assess as normal, but are also self-aware enough to acknowledge (rightly or wrongly) they're not average.

Certainly I have felt overwhelmed with the 'why have they broken so many conventions?' sensation with, invariably, audio apps on microsoft platforms - but OTOH the implied expectation that all software should have a comparably broken UI as mildly modern microsoft word versions expresses a collective poverty of expectations.

    ffmpeg -i example.mkv example.mp4

In almost all cases I don’t want to mess with the defaults, because I know diddly about video formats.

One of the truest things I've read on HN. I've also tried to visit this concept with a small free image app I made (https://gerry7.itch.io/cool-banana). Did it for myself really, but thought others might find it useful too. Fed up with too many options.

It’s like creating a new tv controller with fewer options.

Also this was always kinda of a myth often.

That aside, OP was complaining about software written by "random people". Thing is, people working in companies that write proprietary software are equally "random" in that sense. We know that some of them are North Korean agents, for example.

I do not readily empathize with people who are scared of software, because my generation grows up tinkering with software. I'd like to understand why people would become scared of software in the first place.

The thing is this takes a lot of resources to get right. FOSS developers simply don't have the wherewithal - money, inclination or taste - to do this. So, by default, there are no simple things. Everything's complex, everything needs training. And this is okay because the main users of FOSS software is others of a similar bend as the developers themselves.

The things the user does most frequently need to be the easiest things to do.

You expose the stuff the user needs to do quickly without a lot of fuss, and you can bury the edge cases in menus.

Sadly a lot of software has this inverted.

> Normal people often struggle with converting video. ... the format will be weird. (Weird, broadly defined, is anything that won’t play in QuickTime or upload to Facebook.)"

Except normal people don't use MacOS and don't even know what QuickTime is. Including the US, the MacOS user share is apparently ~11%. Take the US out, and that drops to something like... 6%, I guess? And Macs are expensive - prohibitively expensive for people in most countries. So, normal people use Windows I'm afraid.

https://gs.statcounter.com/os-market-share/desktop/worldwide

In fact, if you disregard the US, Linux user share seems to be around half of the Mac share, making the perspective of "normal people use Macs not FOSS" even sillier.

-----

PS - Yes, I know the quality of such statistics is low, if you can find better-quality user share analysis please post the link.

You should know the common retort - but it's different 20%! So you can't create a one-button UI that covers 80%

But the challenge is real, though mostly "unsolvable" as there is too much friction in making good easily customizable UIs

It's scary for folks who are used to transactional relationships to encounter these different mindsets.

WHY IS THERE CODE??? MAKE A FUCKING .EXE FILE AND GIVE IT TO ME. these dumbfucks think that everyone is a developer and understands code. well i am not and i don't understand it. I only know to download and install applications. SO WHY THE FUCK IS THERE CODE? make an EXE file and give it to me. STUPID FUCKING SMELLY NERDS"

I also heard that, once you try to apply this concept, you see that everyone needs a different 20%. Any thoughts on this?

You can always cherry pick apps to fit a narrative.

FOSS apps with simple interfaces: Signal, Firefox, VLC, Gnome [1], Organic Maps, etc, the list goes on and on.

[1] it’s not a simple app but I think there’s a good argument to be made that it’s simpler/cleaner than commercial competitors.

https://contemporary-home-computing.org/RUE/

That's what "UX" is all about. "Scripting the users", minimizing and channeling their interactions within the system. Providing one button that does exactly what they want. No need to "scare" them with magical computer technology. No need for them to have access to any of it.

It's something that should be resisted, not encouraged. Otherwise you get generations of technologically illiterate people who don't know what a directory is. Most importantly, this is how corporations justify locking us out of our own devices.

> We are giving up our last rights and freedoms for “experiences,” for the questionable comfort of “natural interaction.” But there is no natural interaction, and there are no invisible computers, there only hidden ones.

> Every victory of experience design: a new product “telling the story,” or an interface meeting the “exact needs of the customer, without fuss or bother” widens the gap in between a person and a personal computer.

> The morning after “experience design:” interface-less, desposible hardware, personal hard disc shredders, primitive customization via mechanical means, rewiring, reassembling, making holes into hard disks, in order to to delete, to logout, to “view offline.”

I proactively stopped that decades ago.

"Oh, you use Windows? Sorry, I haven't used it in over a decade so I can't help. If you have any Linux questions, let me know!"

BUT with time and a variable effort a regular user can get accustomed to the new philosophy and be successful. Either by persistant use, by using different OSS apps in series or by touching the command line. Happy user of Firefox, Libre office, Avidemux, Virt-manager (sic)

Free and open source developers are free to build whatever the heck software they want on the basis of "I find this software neat/useful/funny, you can use it too if you'd like".

The way it works is you grab the sources, make a fork, implement your desired changes (e.g. hide 80% of the features), and do a release that is in line with your own vision. "But that's a lot of work" someone might say, ... and yet people routinely think someone else should do such volumes of work for them in order to ensure a project is in line with their needs.

Please assume I'm smarter than I actually am -- I will figure it out no problems. I like complex interfaces that allow me to do my task faster, especially if I'm using it often (e.g. for work).

For telling software devs to embrace traditional design wisdom, using TV remotes is an interesting example - cause aside from the commonly used functionality people actually care about (channels, volume, on/off, maybe subtitles/audio language) the rest should just be hidden under a menu and the fact that this isn't the case demonstrates bad design.

It's probably some legacy garbage, along the lines of everyone having an idea for what a TV remote is "supposed" to look like and therefore the manufacturers putting on buttons in plain view that will never get used and that you'd sometimes need the manual to even understand.

At the same time, it might also be possible that the FOSS software that's made for power users or even just people with needs that are slightly more complex than the baseline is never going to be suited for a casual user - for example, dumbing down Handbrake and hiding functionality power users actually do use under a bunch of menus would be really annoying for them and would slow them down.

You can try to add "simple" and "advanced" views of your UI, but that's the real disconnect here - different users. Building simplified versions with sane defaults seems nice for when there is a userbase that needs it.

The really hard problem to solve is making an UI where the simple thing is easy and the complex thing is still possible.

But that requires 1) strong leadership 2) people with the correct skill set for UX design.

Making a clean UI means cutting things out. And that's not easy in many large OSS projects because every menu item and every button is someone's pet feature. The leaders in the projects are often the most senior _developers_, not UX experts. It's (I'm assuming) a lot less common to have good telemetry and user labs in OSS than it is for commercial software. So you also might not know exactly what features people use and how they use them, making it even harder to remove features.

I think the author is absolutely right. If Handbrake is intimidating, or hard to use without reading a manual in order to do just the simple use case that 80% of users have, then they have failed in making a good UX. A good UX would make the simple thing easy without sacrificing power for the complex case. And the author is absolutely having the right idea when making a simpler wrapper for the powerful software.

I’ve been ripping old DVDs recently. I just want something that feels simple from Handbrake: a video file I can play on my Apple TV that has subtitles that work (not burned in!) with video and audio quality indistinguishable from playing the DVD (don’t scale the video size or mess with the frame rate!), at as small a file size as is practical. I’m prepared for the process to be slow.

I’ve been messing with settings and reading forum posts (probably from similarly qualified neophytes) for a day now and think I’ve got something that works - though I have a nagging suspicion the file size isn’t as small as it could be and the quality isn’t as good as it could be. And despite saving it as a preset, I for some reason have to manually stop the subtitles from being burned in for every new rip.

Surely what I want is what almost everyone wants‽ Is there a simple way to get it? (I think this is a rhetorical question but would love it not to be…)

Related problem is that software business, and through it UI/UX, is obsessed about gaining new users, so everything is designed for ease of onboarding, at the expense of ergonomics and efficiency of continued use. It's backwards and dumb, and subscriptions should theoretically prevent this, but the truth is, software products are pretty much unique (there's rarely an actual competitor to switch to with the same set of features you need), and most products die or get killed before they move past the growth phase, so incentives align to catering for first-timers instead of already paying users.

And then UI/UX gets trotted as some industrial design wisdom, and this kind of backwards approach starts infecting design of physical products...

I use it mostly for work and academic papers, not for amusement.

Most of the regular simple pdf viewers on the PC don't have this kind of productivity functionality in mind. They might have some, but in general they are not designed to work with read-only text.

It's a little harder to make an easy version

Making the progressive version is very difficult. Where you can please one audience with the powerful and easy versions, you can often disappoint both with the progressive version despite it taking much more effort.

In my personal experience, you're lucky if free software has the budget (time or money) to get to easy. There's very little free software that makes it to progressive.

And then you need to implement that, which is never an easy task, and maintain the eternal vigilance to both adhere to the vision but also fit future changes into that vision (or vice versa).

All of that is already hard to do when you're trying to build something. Only harder in a highly collaborative voluntary project where it's difficult or maybe even impossible to take that sort of ownership.

Is this an inherently bad thing if the software architecture is closely aligned with the problem it solves?

Maybe it's the architecture that was bad. Of course there are implementation details the user shouldn't care about and it's only sane to hide those. I'm curious how/why a user workflow would not be obviously composed of architectural features to even a casual user. Is it that the user interface was too granular or something else?

I find that just naming things according to the behavior a layperson would expect can make all the difference. I say all this because it's equally confusing when the developer hides way too much. Those developers seem to lack experience outside their own domain and overcomplicate what could have just been named better.

Later the missing pieces were added, we had "two buttons" and the resulting user confusion because they did not know and could not be taught whether a container makes sense for a particular lab.

They always answered me "it works well".

But what I found during my next visit is a paper with a telephone number of computer helpers, and the laptop was running a fresh copy of Windows, presumably installed by these helpers.

There are only three people in my house, two of which appear to be happy with macOS and one (me) is happy with Linux.

I am not upset with the job requiring people to use macOS. That job was awful for a whole bunch of wonderful reasons, but that wasn’t one of them. If people expect me to play tech support in my house I want an OS that I understand and isn’t terrible to do it.

What is there to see? You add a bar that takes space. That space can be taken up by something useful. Just like you have apps that hide app title bar and app menus so you can have more space for your precious content. This is especially useful for high-info-density apps like these audio/video/photo authoring ones. Note how tiny those handles are in the video, why do you think that is?

> tradeoff is an incredible degree of customisation

You don't have that tradeoff, neither of the 2 solutions are anywhere close to "incredible customization", so you can pick either without it.

> In terms of precision, they're working on accessibility issues

Working towards what magic solution?

> but I'm not sure how this change is any special than any other UI.

why does it have to be special? Just a bog standard degradation common to any UI (re)design, nothing special about it.

> the modes were horrid

Of course they were. Just like they were horrid in that MS Paint app the dev worked on before. But you can make any UI primitive horrid, even buttons, that's no reason to remove them, but to improve them!

I think it’s essentially survivorship bias. The simple applications don’t get traction and later get abandoned.

So for example, a hypothetical Windows DE could offer XP, 7, and 10 modes which the user can freely switch between which would never change. This delivers on two fronts: first, it presents a familiar, comfortable UI for the user, and second, it offers a promise that most of the popular Linux desktops do not which is that significant changes will not occur, even over long time scales.

I disagree on LLMs/terminal use. Too many things can go wrong in too many different ways for LLMs to be of much use to users for troubleshooting in many cases, and there's also the issue of the user even knowing what to ask for in the first place (even many moderately technical users aren't going to have the foggiest clue what a Debian package, MATE, HEAD, or upstream are).

The system really just needs to be engineered to 1) be extremely robust and not break in the first place 2) when it does break, have the ability to silently self-heal 99% of the time. A non-essential but excellent bonus would be 3) to be able to express what's wrong and what needs to be done to the user in that last 1%. This won't be easy to accomplish, but the first distro that does will be richly rewarded with user loyalty.

they are. ive only used ffmpeg via llm, and its easy to get the LLM to make the right incantation as part of a multi-step workflow.

my own lack of understanding of video formats is still a problem, but getting ffmeg to do the right thing only takes a vague notion

I don't think that's true at all. The tool linked here is exactly the kind of utility that does one single task and that people are happy to download. Most people use software to solve a problem, not to play around with it and figure out if they have a use for it.

It's certainly possible they can't read. But more likely they're perfectly intelligent and simply don't appreciate being forced to deal with unnecessary complexity to complete a simple task.

(Someone else's comment reminded me of the CHI video of Allen Newell and Ron Kaplan, two brilliant AI pioneers, struggling with a poorly-designed copy machine https://athinkingperson.com/2010/06/02/where-the-big-green-c...)

I wonder who is responsible for the existence of such people.

"Audio 1 #1" "Audio 1 #1" "Audio 1 #1"

"Audio 1 #1" "Audio 1 #1"

names replacing the audio wave height!

But sure, if you need names permanently right there and are ok to lose space to show them, and if the handle is inconveniently small to only fit the text, then yes, you wouldn't lose space in that case. You'd only have other issues.

But that coupling likely has other design implications, e.g., you're unlikely to get an option to only show names on hover instead of having a bar, or to show names as an overlay (in many cases the names aren't that long to need to take the height of the the whole segment)

The best method I have found is to use the interface and fix the parts that annoy me. After decades of games and internet I think we all know what good interfaces feel like. Smooth and seamless to get a particular job done. If it doesn't feel good to use it is going to cause problems with users.

Thats said. I see the software they use on the sales side. People will learn complexity if they have to.

The toughest hurdle to overcome as a developer is not thinking about the gui as a thin client for the application, because to the user, the gui is the application. Developers intuitively keep state in their head and know what to look for in a complex field of information, and often get frustrated when not everything is visible all at once. Regular users are quite different— think about what problems people use your software to solve, think about the process they’d use to solve them, and break it down into a few primary phases or steps, and then consider everything they’d want to know or be able to do in each of those steps. Then, figure out how you’re going to give focus to those things… this could be as drastic as each step having its own screen, or as subtle as putting the cursor in a different field.

Visually grouping things, by itself, is a whole thing. Important things to consider that are conceptually simple but difficult to really master are informational hierarchy and how to convey that through visual hierarchy, gestalt, implied lines, type hierarchy, thematic grouping (all buttons that initiate a certain type of action, for example, might have rounded corners.)

You want to communicate the state of whatever process, what’s required to move forward and how the user can make that happen, and avoid unintentionally communicating things that are unhelpful. For example, putting a bunch of buttons on the same vertical axis might look nice, but it could imply a relationship that doesn’t exist. That sort of thing.

A book that helps get you into the designing mindset even if it isn’t directly related to interface design is Don Norman’s The Design of Everyday Things. People criticize it like it’s an academic tome — don’t take it so seriously. It shows a way of critically thinking about things from the users perspective, and that’s the most important part of design.

For teasing apart complex workflows I'd suggest Holtzblatt and Beyer's Contextual Design book, I taught a user-centered research and design class many years ago and used that as our textbook, hopefully it still holds up.

For organizing complex applications I like to start with affinity diagrams, card sorts, and collaborative whiteboard sessions. And of course once you have a working prototype, spend as much time as possible quietly watching people interact with your software.

Google could do this years ago.

It might be a problem that you have to search for the solution to every time you have it, but you'll find the solution quickly because many other people also experience the problem.

The DE needs to be as close to a drop-in replacement as possible while remaining legally distinct. The less the user needs to relearn the better.

How many of them are paid? I know MuseScore, Penpot, and Blender have paid for almost all of their design work (because they have paid staff)

Not just a relevancy problem, it's much easier to get free development work in OSS than design work. It's a decades-long problem.

Well, there are different issues.

Reading a manual is the best you can do, theoretically. But Linux CLI tools have terrible manuals.

I read over the ssh man page multiple times looking for functionality that was available. But the man page failed to make that clear. I had to learn about it from random tutorials instead.

I've been reading lvm documentation recently and it shows some bizarre patterns. Stuff like "for more on this see [related man page]", where [related man page] doesn't have any "more on this". Or, here's what happens if you try to get CLI help:

1. You say `pvs --help`, and get a summary of what flags you can provide to the tool. The big one is -o, documented as `[ -o|--options String ]`. The String defines the information you want. All you have to do is provide the right "options" and you're good. What are they? Well, the --help output ends with this: "Use --longhelp to show all options and advanced commands."

2. Invoke --longhelp and you get nothing about options or advanced commands, although you do get some documentation about the syntax of referring to volumes.

3. Check the man page, and the options aren't there either. Buried inside the documentation for -o is the following sentence: "Use -o help to view the list of all available fields."

4. Back to the command line. `pvs -o help` actually will provide the relevant documentation.

Reading a manual would be fine... if it actually contained the information it was supposed to, arranged in some kind of logically-organized structure. Instead, information on any given topic is spread out across several different types of documentation, with broken cross-references and suggestions that you should try doing the wrong thing.

I'm picking on man pages here, but actually Microsoft's official documentation for their various .NET stuff has the same problem at least as badly.

Silksong Daily News went from videos of a voiceover saying "There has been no news for today" over a static image background to (sometimes) being scripted stop-motion videos.

Sometimes the best solution is not the most widely-encouraged one.

Sometimes it's just me firing up some SQL queries and discovering "Well this happened 3 times ... ever ..." and we do nothing ;)

The usual situation is that the business department hires someone with a modicum of talent or interest in tech, who then uses Access to build an application that automates or helps with some aspect of the department's work. They then leave (in a couple of cases these people were just interns) and the IT department is then called in to fix everything when it inevitably goes wrong. We're faced with a bunch of beginner spaghetti code [0], utterly terrible schema, no documentation, no spec, no structure, and tasked with fixing it urgently. This monster is now business-critical because in the three months it's been running the rest of the department has forgotten how to do the process the old way, and that process is time-critical.

Spinning up a proper project to replace this application isn't feasible in the short term, because there are processes around creating software in the organisation, for very good reasons learned painfully from old mistakes, and there just isn't time to go through that. We have to fix what we can and get it working immediately. And, of course, these fixes cause havoc with the project planning of all our other projects because they're unpredictable, urgent, and high priority. This delays all the other projects and helps to give IT a reputation as taking too long and not delivering on our promised schedules.

So yeah, what appears to be the best solution from a non-IT perspective is a long, long way from the best solution from an IT perspective.

[0] and other messes; in one case the code refused to work unless a field in the application had the author's name in it, for no other reason than vanity, and they'd obfuscated the code that checked for that. Took me a couple of hours to work out wtf they'd done and pull it all out.

Well, if people fail at that first five minutes, the subsequent thousand hours most often never happens.

I don't see Windows as having much of an edge there. Lots of things seem to change on Windows just for change's sake. I get so tired of the churn on Windows versions and finding how to disable the new crummy features. If you want to avoid relearning all the time, something simple like XFCE is going to be way better.

Other engineering disciplines are simpler because you can only have complexity in three dimensions. While in software complexitiy would be everywhere.

Crazy to believe that

On the other hand, if you are using your car for a decade and feel it needs a new belt - then get a new belt. Worst case scenario- you will lose some money but learn a bit more about an item you use everyday.

Experts don't have your instincts as a user.

A new design metaphor can be "completely valid" and simultaneously an aggravating rug pull if it is pitched as a new numbered version of an existing program---especially an existing desktop environment that many people use daily---rather than as a new program.

> Gnome 3 was a big update and adding options, which does happen, is not free. There were changes from Gnome 2 and 3 and adding some options "back" from Gnome 2 is really asking for that feature to be rewritten from scratch (not all the time, but a lot of the time).

If the "next version" of a software project is really a near-total rewrite, such that many-to-most features from the previous version must be rewritten from scratch, then you should start a new project and pick a new name if you do not want your current users comparing the new version to the previous version. Whether or not those users appreciate the cost of feature rewrites to the developers' satisfaction, they already have working software with a long list of features and a version number one lower.

KDE had a similar problem moving from 3.5 to 4 (also a major rewrite), but the initial wave of complaints had more to do with instability and heavy resource use because they didn't abandon the desktop metaphor entirely. They also explicitly had a roadmap of building back in many of 3.5's features as time went on, which made it a less radical transition.

It's all ancient history at this point, at least on software timescales. But the Gnome 2 to Gnome 3 transition is up there with Python 2.7 to Python 3 as an example of how not to manage or implement a major change to a widely used piece of software.

The funniest thing to me is I used to think of Gnome 3 as a effort toward Apple-esque design which wasn't as well put together as MacOS... But now, even though Gnome today is still not up to the consistency of 2011 MacOS, it is more consistent than 2025 MacOS because Apple has been driving drunk on desktop software design for a decade and a half.

After dealing with this kind of stuff for 14 years, it shouldn't be surprising that you don't have a lot of folk left who are willing to extend good faith to Gnome devs.

My buddy has almost the exact same story about his M1 iMac. Just under 4 years, now it crashes and forces a safe mode boot randomly. The computer can take upwards of 10 minutes to even start up. They gave him the same business, exact same repair offering, and he’s moving on like I am. I’ve got 1 other friend with a similar unfolding right now, none of these situations were with laptops.

Most people just keep the default. When the default is Linux (say, the Steam Deck), most people just keep Linux.

This is the second time this has happened to my family from Windows, on different computers.

Heck, even computing education (and the profession even!) has been propped up by GUIs. After my first year in CS, there were like only three to five of us in a section of forty to fifty who could compile Java from the command line, who would dare edit PATH variables. I'm pretty sure that number didn't improve by much when we graduated. A lot of professionals wouldn't touch a CLI either. I'm not saying they are bad programmers but fact of the matter is there are competent professional programmers who pretty much just expect a working machine handed to them by IT and then expect DevOps to fix Jenkins when it's borked out.

Remember: HN isn't all programmers. There are more out there.

> But, if we assume the user has never seen a graphical application before, then likely all GUI tools will be useless too.

We don't even need to assume, we just need to look at history. GUIs came with a huge amount of educational campaigning behind it, be it corporate (i.e., ads/training programs that teach users how to use their products) or even government campaigns (i.e., computer literacy classes, computer curriculum integrated at school). That's of course followed by man-years upon man-years of usability studies and the bigger vendors keeping consistent GUI metaphors across their products.

Before all of this, users did ask the questions that you enumerated and certain demographics still do to this day.

> Of all of that, CLI tools rely on some of the least amount of assumptions by their nature - they're low fidelity, forced to be simple.

"Everything should be made simple, but not simpler." Has it occurred to you that maybe CLI tools assume too little?

If your mechanic is too stupid to recognize the problem after you explain it then you don't have a mechanic, the set of hands you are directing is basically unskilled labor.

There are heaps of Photoshop tutorials on YouTube, which wouldn't be necessary if what you said were true.

I used GIMP to do MS paint stuff years ago when I used it fairly regularly.

GIMP is always a whipping boy for UI design on forums like this and I think it is pretty unfair. It is a pretty good program comparatively. If you want to see bad UI design a much better example is something like Visual Studio. What a mess.

This is just straight up not true. You're only saying this because you, presumably, have used Photoshop.

It has a million buttons, layers are a thing, there's a million tools, etc. No, they can't just pick it up because it's complex software for a complex problem domain.

Maybe you disagree. Okay. Pick a different example. 3D Max? Why aren't studios using Microsoft Paint 3D instead of 3D max?

It's like dark patterns are the ONLY pattern these days.. WTF did we go wrong?

Then the world threw away the menus, adopted an idiotic “ribbon” that uses more screen real estate. Unsatisfied, we dumbed down desktop apps to look like mobile apps, even though input technology remains different.

Websites also decided to avoid blue underlined text for links and be as nonstandard as possible.

Frankly, developers did UI better before UI designers went off the deep end.

I.e. done right, it should be not just possible but completely natural for a random team lead in the mail room to call IT and ask, "hey, we need a yellow highlighter in the sheet for packages that Steve from ACME Shipping needs to pick on extra evening run, can you add it?", and the answer should be "sure!" and they should have the new feature within an hour.

Yes, YOLO development straight on prod is acceptable. It's what everyone else is doing all the time, in every aspect of the business. It's time for developers to stop insisting they're special and normal rules don't apply to them.

The single most valuable tool is user testing. However it really takes quite a few rounds of actually creating a design and seeing how wrong you saw the other person’s capabilities, to grok how powerful user testing is in revealing your own biases.

And it’s not hard at all at core. The most important lesson really is a bit of humility. Actually shutting up and observing what real users do when not intervened.

Shameless plug, my intro to user testing: https://savolai.net/ux/the-why-and-the-how-usability-testing...

Which is a huge reason that learning a RAD (rapid application development - emphasis on rapid) tool is a pretty useful skill.

This leads to the exact problem OP brings up: who fixes it if it breaks? If it becomes critical, now other priorities go unhandled as a person or team are dragged into resolution.

I’ll bring a couple more counter arguments:

- When I was running an internal enablement team, I reckon I had 12 months worth of work of these simple requests at any given point in time.

- Even that time saving might not be worth it, if it means those 4 hours could have been spent building something the company can sell (which for a SaaS product, is literally millions over its lifetime).

Just to be clear, I’m not saying you did the wrong thing at all. Hell, I’ve done this stuff myself. I’m just pointing out it’s not as easy as “just spend 4 hours on it and it’s done!” I’d go on but I think I’d just end up regurgitating the article.

Pretty much everyone is a power user of SOME software. That might be Excel, that might be their payroll processor, that might be their employee data platform. Because you have to be if you work a normal desk job.

If Excel was simpler and had an intuitive UI, it would be worthless. Because simple UI works for the first 100 hours, maybe. Then it's actively an obstacle because you need to do eccentric shit as fast as possible and you can't.

Then, that's where the keyboard shortcuts and 100 buttons shoved on a page somewhere come in. That's where the lack of whitespace comes in. Those aren't downsides anymore.

This means they want to add features they couldn't get anywhere else, and already know how to use the existing UI. Onboarding new users is just not their problem or something they care about - They are interested in their own utility, because they aren't getting paid to care about someone else's.

It's not a "nerd" thing.

i think the bigger issue is that the power users usecases are different from the non-power users. not a skillset problem, but an incentive one

> You can and will happily do things your users/customers hate if ... you dont have to face their criticisms directly.

A lot of software developers can't take criticism well when it comes to their pet projects. The entire FreeCAD community, for instance, is based entirely around the idea that FreeCAD is fine and the people criticising it are wrong and have an axe to grind, when that is exactly backwards.

If you streamline a shitty process, you will have diarrhea...

Unfortunately, most processes suck and need improvement. It isn't actually IT's job to improve processes. But almost always, IT is the only department that is able to change those processes nowadays since they are usually tied to some combination of lore, traditions, spreadsheets and misused third-party software.

If you just streamline what is there, you are cementing those broken processes.

Developers seem to have a product that people can actually attach a value to, but art and music; not so much. They seem to be in different Venn circles.

In all of it, we do stuff because of the love of the craft. One of the deeper satisfactions, for me, is when folks appreciate my work (payment is almost irrelevant; except for "keeping score"). It's pretty infuriating, to have someone treat my work as if it is a cheap commodity. There's a famous Star Trek scene, where Scotty and his crew are being disciplined for a bar fight with some Klingons[0], and Scotty throws the first punch. I can relate.

[0] https://www.youtube.com/watch?v=5rsZfcz3h1s

I think this is because there are plenty of software nerds with an interest in typography who want to see more free fonts available.

Not sure how that happens with a painting, even a digital one.

But more importantly, most of them don't really care beyond "oh copyright's the thing that lets me sue big company man[0]".

The real impediment to CC-licensed creative works is that creativity resists standardization. The reason why we have https://xkcd.com/2347/ is because software wants to be standardized; it's not really a creative work no matter what CONTU says. You can have an OS kernel project's development funded entirely off the back of people who need "this thing but a little different". You can't do the same for creativity, because the vast majority of creative works are one-and-done. You make it, you sell it, and it's done. Maybe you make sequels, or prequels, or spinoffs, but all of those are going to be entirely new stories maybe using some of the same characters or settings.

[0] Which itself is legally ignorant because the cost of maintaining a lawsuit against a legal behemoth is huge even if you're entirely in the right

Graphic artists are creating graphics editors (Gimp, Krita, Blender, ComfyUI, etc.) with tons of options.

That's an illusion. The reality is, it's all hacky solutions on top of hacky solutions. Even in manufacturing: the spec may be fixed, and the factory line produces identical products by the million - but the spec was developed through an ad-hoc process, and the factory line itself is a pile of hacks that needs continued tuning to operate. And there is no perfectly specced out procedure for retooling a factory line to support the newest spec that came out of design department - retooling is, in itself, a small R&D project.

> Also, if you have ever worked with anyone trying to get specifications worked out, you’ll see that most people (including devs) rely on intuition rather than checklists and will always forget to tell you something that is critical.

This is the dirty truth about the universe - human organizations are piles of hacks, always in flux; and so is life itself. The sameness and harmony we see in nature is an illusion brought on by scale (in two ways - at large scale, because we live too short to see changes happening; at small scale, because the chaos at biomolecular level averages out to something simpler at the scale we can perceive).

Order and structure are not the default. It takes hard work to create and maintain them, so it's better be worth the cost. The prevalence of Excel-based hacks in corporate is a proof positive that, for internal software, it usually isn't worth it, despite what the IT department thinks.

> The thing is that cost of changes in the business can be a simple memo. But for software that usually means redesign.

Which is why you shouldn't be building cathedrals that need expensive rework every other week because of some random memo. Instead, go down to where people work; see them tweaking their shovels, take those shovels and make the tweak they want the proper way.

If it is your job, then go do it as a job. But we all have jobs. Free software is what we do in our free time. Artists don't seem to have this distinction. They expect to be paid to do a hobby.

There’s a very good reason for me to be asking for gratis work. I regularly do tens of thousands of dollars’ worth of work for free.

That's my point.

Kinda the whole goal behind (and "benefit" of) microservices, right? Totally independent dev teams, all uncoupled from each other, no need to look inside at the code, language-independent - just pass data according to an API and dont look behind the curtain.

As a programmer, working with a good graphic designer can be very frustrating, as they can demand that I make changes that seem ridiculous, to me, but, after the product ships, makes all the difference. I've never actually gotten used to it.

That's also why it's so difficult to get a "full monty" treatment, from a designer, donating their time.

Visual art is millennia older and has found many more niches, so, besides there being a very clear history and sensibility for what is actually fundamental vs industry smoke and mirrors, for every artist you encounter, the likelihood that their goals and interests happen to coincide with "improve the experience of this software" is proportionately lower than in development roles. Calling it drudgery isn't accurate because artists do get the bug for solving repetitive drawing problems and sinking hours into rendering out little details, but the basic motive for it is also likely to be "draw my OCs kissing", with no context of collaboration with anyone else or building a particular career path. The intersection between personal motives and commerce filters a lot of people out of the art pool, and the particular motives of software filters them a second time. The artists with leftover free time may use it for personal indulgences.

Conversely, it's implicit that if you're employed as a developer, that there is someone else that you are talking to who depends on your code and its precise operation, and the job itself is collaborative, with many hands potentially touching the same code and every aspect of it discussed to death. You want to solve a certain issue that hasn't yet been tackled, so you write the first attempt. Then someone else comes along and tries to improve on it. And because of that, the shape of the work and how you approach it remains similar across many kinds of roles, even as the technical details shift. As a result, you end up with a healthy amount of free-time software that is made to a professional standard simply because someone wanted a thing solved so they picked up a hammer.

And even if they're wrong about which one is typically harder, they weren't saying it was easy, and weren't saying it was significantly easier than programming.