Hacker News Reader

Hacker News

Comment by aero-glide2 | Hacker News Reader

Parent Full thread

aero-glide2

Poor UX seems to be a recurring theme with open source projects. Anyone knows why?

View on HN

Here is how it goes:

- you slap together a low effort UI in order to test your code.

- You use this UI so much during development that it becomes "intuitive" for you.

- Early adopters are interested in functionality, so they can overlook a poor UI for a while.

- They use this poor UI so much that it becomes "intuitive" for them.

- Early adopters even help newcomers to overcome the poor UI.

- Meanwhile you develop more features and postpone the "less valuable" UI improvement.

- At some point there is so much functionality hooked to the UI that it would be a drag to change it. Also as it was quick-and-dirty stuff it would also be very difficult for others to redo the UI.

- You find a way out: pretend that it is vital to extract the library hidden in your program, so that "anyone will be able to put the UI they want on top of it so leave me alone".

- This further postpone the new UI, because potential UI makers have to wait until the library is done, and then users have to wait until the UI designer and implementer does their thing.

- It takes too long because portability issues and API design is not so easy, so you lose your UI designers one by one. So you have to make a low-effort UI to test and demo your library.

Apart from all issues mentioned so far (all valid (edit: utunga got there while I was still writing)), there's also a problem where you can't apply good UX in small patches here and there. You can fix some terrible experience where it's actually a problem, but to really improve UX in an app, you need to touch almost everything at the same time, which means a lot of time spent on the task and required commitment to the idea from the leaders.

That's really hard to organise in opensource world. And when you try to introduce leadership which can do it and try to collect information, you get the issues Audacity ran into. Sure, Tentacrul can lead the UX effort and will make Audacity much better, but the community impact was pretty negative.

The only opensource project I really remember pulling off a well organised UX update is Blender. And even that was after years of people screaming "don't touch right-click-to-select, we're used to it and newbies need to learn".

What happened with the Audacity community when Tantacrul started?

edit: found the thing where people got upset about telemetry - https://github.com/audacity/audacity/discussions/889

The telemetry was one thing, but there was also a few people with "what do you mean muse owns this project now? I'm forking rather than accepting forced leaders".

A good solution to this is the traditional[1][2] UNIX approach of separating mechanism and UI. First develop the core functionality without a UI as a library (or daemon or whatever). The actual UI is then developed as a front-end to the library. This allows multiple front-ends to coexist so a new UI can be developed without disturbing the people that like the old version.

Too many projects tightly couple their UI and mechanism, which always leads to problems.

[1] http://www.catb.org/~esr/writings/taoup/html/ch01s06.html#id...

[2] http://www.catb.org/~esr/writings/taoup/html/ch04s04.html

Interesting way to develop a program while keeping ui seperated, would have never thought of that approach. But in my experience, developing the UI alongside also leads to insights into your product you hadn't foreseen.

Sure! Developing both the backend and an initial UI front end in parallel is a good idea. The point is to separate different aspects of the program into manageable, modular sections. Separating the mechanism and UI is just an another way to practice information hiding and modular programming.

I agree with your first point but I disagree that telemetry is required to improve UX. You can "collect information" in a respectful way by asking users instead of stalking them (and letting a malicious third-party such as Google Analytics do so as well).

>> Poor UX with open source projects. Anyone knows why?

Quoting from a commenting on this thread:

"The only thing that can confuse people is the certificate security system... ..That is an issue of general technical illiteracy, that Mumble cannot address."

I think this sums it up. While not universal, OSS has a higher tendency to not-my-problem certain things. Often this is UX, other things too.

OTOH, OSS tends to delight at taking ownership of many other types of problems. Interoperability, multiple implementations, advanced features, user choice, etc. Stuff that proprietary software tends to be bad at.

The thing that drives facebook or Tinder to make their software addictive is the same thing that drives them to make it usable for the average person.

Many reasons:

* Code is more interesting to the author than user experience

* High familiarity with a tool, as authors gain by working on a tool, will normalize bad UX

* Free software (specifically) often attracts a type of person that has very non-mainstream UX tastes

And by the time anyone's developing for the project, they're already entirely familiar with all the quirks and UI decisions.

It takes real top-down leadership (or a one-man project) to be able to change those things.

...and yet sometimes even that is not enough.

A recent story I have been fascinated by involves the Android reader RedditSync - not OSS, but championed by a fearless Solo Dev. He released V20 after so long and so much feature feedback from dedicated users in the Play Store beta channel. Immediate community revolt from V19 users who just liked the UI the way it was and never new there was a beta program in the first place. Much subreddit infighting. Rollback. Cooling off period. Now its basically forked with X users on a 'beta'V20 and Y users on the Play Store V19. [1]

Honestly my heart goes out to the dev who solid knocks out feature requests and just didn't expect the level of cling his old UI had developed. Some people were proper angry and he was in a tough spot.

Anyhow its probably better material for a business school case study but point here is even a one man project can get caught by UI pattern bias.

[1] https://redd.it/mtgmqn

It's an important question that deserves a considered response.

IMHO its more than just lack of designers (though that's important) it's actually a balance of power thing.

Delivering really good UX requires taking a design-led approach to the whole project. Unfortunately this conflicts with one of the main reasons coders enjoy working on open source. No management, no customers and you get to work on what you want. Design it for yourself, not others.

But of course, the interface that the average coder wants is nothing like the interface that the average user needs - especially if the average coder is intimately familiar with all the features. Most coders appreciate this and try to design a 'friendly' interface but at the end of the day it's a power imbalance. In a conflict between clean design or adding more features, a team led by programmers is going to prioritize features.

Just guessing: There's not a lot of designers in open-source circles. They tend to get paid a lot less than devs and so many don't get the privilege to care as much about FOSS.

When I went to design school and tried to use Inkscape I was laughed at. The day-1 was basically here's a Mac, here's Adobe, now learn to play in this sandbox (which I did til post college). FOSS tends to love Linux and BSDs support, yet most popular design tools aren't available there.

> They tend to get paid a lot less than devs and so many don't get the privilege to care as much about FOSS.

I do not follow this line of reasoning. There are Indian FOSS developers being paid 10 times less compared to their SV peers. Why would your salary matter? Surely, what‘s important is the amount of dispensable time you have, not your salary.

Say you don't have a lot of cash and you want microblogging and VoIP. Do you spend money to host your own Mastodon and Mumble servers, or use one where many admins (understandably) require payment or donations to cover costs, or do you use the free-because-you're-the-product Twitter and Discord? Do you use GMail or pay for Posteo/ProtonMail/Fastmail/etc.? Do you use the centralizing, closed-source GitHub or pay for SourceHut or host your own Gitea server? Can you afford to build a rack at home to self-host and invest in the skill to maintain and secure it? Do you invest time in learning GIMP despite lower-quality, community tutorials because it's free (as in beer and freedom) or do you follow the crowd and use Creative Suite or Affinity Studio because it's the tool most your jobs will expect you to use?

I think it is (unfortunately) a privilege of being able to afford the FOSS and privacy-focused alternatives--through money and time. A good salary gives you room for privilege. I don't think you can separate finances from the equation. Many people are just out there trying to take the easiest route to survive, and FOSS isn't as easy.

(Heck, even speaking English is a privilege many here on HN have. Many FOSS projects are only in English. I've been in Thailand for a while now and while the much of the youth demographics resents its government, almost no one knows about decentralized, private, FOSS services because it hasn't been localized and people can't afford the bill either--and as such the government has many times censored Facebook and YouTube and other centralized systems.)

>I think it is (unfortunately) a privilege of being able to afford the FOSS and privacy-focused alternatives--through money and time. A good salary gives you room for privilege. I don't think you can separate finances from the equation. Many people are just out there trying to take the easiest route to survive, and FOSS isn't as easy.

Reminds me of a quote from http://theantisense.com/2018/10/26/biohacking-trash-flavored...

"I understand that “teaching a man to fish” is a thing, but that metaphor breaks down under the constraints of time and the pressures modern civilization. The ability to make tools stems from access to time. The freedom of time comes from having money. There’s a reason all those Renaissance dudes knew 7 languages, had spare time to write poetry, write essays on philosophy, and built their own laboratories. It’s because someone was doing their dishes and laundry for them. Someone else was subsidizing the overhead."

(The article make a rather different point and that quote is slightly cherrypicked, btw. It's a good article, I recommend it.)

I would like to be involved, but I'm not really sure how. The open source culture and tooling is strictly all about code. At least, that's the way it feels to me. Very unapproachable. And often times, there is zero signal that they would even be interested in getting the help. From my experience.

For what it's worth, I'm a design lead and make six figures. I don't think that has much to do with anything.

In general most OSS projects don’t have the resources to spend on UX development -and- developing the core functionality. I don’t think most projects would be against UX contributions. You could just create an issue for a project to discuss it, or bring it up wherever their community is.

The GUI was built in the era of windows XP and Skype. And you have to host your own server.

Nothing can compete with discord where you just press a button to create a “server” and send out a link. It all just works and it costs a fortune to run.

No one has enough free time to build a brand new high quality app for mumble which works on 3 desktop OSs and 2 mobile.

You nailed it: THIS is most of the general GUI problem.

"""No one has enough free time to build a brand new high quality app for mumble which works on 3 desktop OSs and 2 mobile."""

It also can't be (whatever windowing kit, E.G. QT) because that requires a big download in addition to the program, and also 'doesn't feel native' or 'doesn't look right' or 'sets off the AV scanner'.

The other escape hatch is electron; which looks "web", but is even _more_ bloated, but at least it doesn't set off the scanners. Instead it just gobbles CPU cycles, memory, and is slow and horrid.

I'm to the point that I don't care what wins, or how horrid writing for it is; I just need a widgets toolkit and bindings that can be developed for ONCE, is hosted with the OS and shared among all apps, and works on Mobile (all of them), Win, OSX, and 'nix.

Electron is what Discord and Teams and Slack use. And Google's stuff just uses web pages.

It's the first time I hear of "sets off the AV scanner" being a major problem for native apps. How frequent is it?

If you don’t get the proper certificates for signing your packages, all the time.

>The other escape hatch is electron; which looks "web", but is even _more_ bloated, but at least it doesn't set off the scanners. Instead it just gobbles CPU cycles, memory, and is slow and horrid.

I keep wondering if something like Godot could win out in GUI-land. https://medium.com/swlh/what-makes-godot-engine-great-for-ad...

I believe this happens because writing high quality UIs which is consistent, is well studied (as in having studied how users react to it in order to improve the worst parts), and is available for multiple platforms, is a HUGE amount of work that would only go forward if people got paid to do it.

So I'd wager that lots of OSS have bad UI because no commercial entity considered that the market is big enough to justify spending resources on it. This is, an external company pouring money at hiring OSS devs to work on the UI, or maybe even the project creators themselves founding a one-person business to sell services or products that require such a good UI.

An example: if Mumble had a huge user base, maybe there would possibly be some company selling high-quality, easy to use desktop applications for it. But reaching that goal is very hard, and most OSS projects never get even a fraction of the traction that would be needed for such commercial efforts.

Because not every free-software project has UX designers working on them? I mean the UI is the frosting on the cake, that you can do in pretty much any language and usually with less knowledge of the backend infrastructure... but not a lot of people are doing this job.

Kudos to the Tor Project and Conversations.im for making decentralized, encrypted communications within everyone's reach.

mumble seems to be power user software. The setup wizard expects one to setup microphone levels, I didn't even have the mic connected. And I have different setups connected at home and at work, which makes me doubt the agility of this configuration (can it adapt to plugging in and removing equipment?)

I think of it like this: open source software is typically written by volunteers. Volunteers with good systems skills but no UX skills can author open source software on their own. Oppositely, volunteers with no systems skills, only UX skills cannot.

This is probably worsened by the fact that people who care about good UX will gravitate towards software with good UX, which is often commercial.

Reply on news.ycombinator.com