26
votes
FOSS and UX (twitter thread)
@Kavaeric:
Let's walk through this, shall we?Say we've decided to make a new FOSS word processor. Call it, I dunno, Libra-Office or O-Pan-Office. Just a thought. Word processors, as you might guess, are also a fairly entrenched market.Who's our target audience?
Here is an unroll via ThreadReaderApp: https://threadreaderapp.com/thread/1391916260896747525.html - it makes it significantly more readable in my opinion.
FOSS user experience might be stupid, but it is seldom hostile like a company holding its users captive — either to milk them of value or out of a misguided notion of simplicity.
It's only Alanis-ironic, but it's still funny.
I appreciate the thread and would welcome any development for more FOSS alternatives to Word and Google products. All good.
Having said that, just one aspect to the thread I have to push back on:
OK, let's review: we're supposed to imagine what the user wants, and then write that down into an "Empathy Map." This is one of the most dangerous (and most common) misconceptions in digital design - that simply by imagining our users, simply by feeling the best of intentions toward empathy, we will have actually listened to customers.
I wrote an entire book on this misconception - but the TLDR is that this lack of real inclusion creates the conditions for huge mistakes. All the time. Billions of dollars wasted, and worse - lives harmed or lost. All because, very consistently, product teams design and deploy systems that are based on the flimsiest foundation: "well, we imagined what our users wanted, and we wrote it all down in a fancy Empathy Map."
I don't mean to come down too hard on this thread, which is written in favor of - as I said - something I support enthusiastically. So I hope it leads to some good outcomes. I just wish that designers and developers would, at long last, abandon these dangerous - and all too common - illusions about imaginary users and the mental application of "empathy."
On top of it being terrible UI to just tell the user to go to a mysterious "temp" directory, I really hate it when programs just decide they're going to take their updating into their own hands. I think that's my Linux usage spoiling me though -- one place I think Linux distros as a whole have shone is their easy-update-all-at-once workflows. It's really great.
On Windows, yeah, I get why this is a thing. But it's super annoying.
I'd dramatically prefer self-updating software to non-updating software. I agree that a centralised manager is even better, but in the absence of that what is it about the in-application update flow you dislike?
Maybe the fact that the application interface can be updated to change the interface willy-nilly after the user has invested countless hours figuring out a way to use it? Or that the app can unilaterally change the terms of use and hold your data/experience hostage? Or that they might update at really inopportune moments?
Understood - so it's the software automatically choosing to install the update that bothers you, not an in-app "update/cancel" prompt à la VLC?
I'd thought you meant you had an issue with software simply including a self updater rather than leaving it to an external tool or to the user directly.
Even the automatically pushed updates do leave me ambivalent, though. I'm immensely sympathetic to the argument that our machines shouldn't do things without asking us, but I'm also aware of the reality that we would have a whole lot more botnets out there if Chrome didn't self-patch. Short of an "emissions test" before you're allowed online, I'm not sure how to reconcile that.
Yup -- While I personally really like the convenience of system level package management (like in linux), I'm quite okay with the VLC model, and leave it to people's tastes and market/consensus mechanisms to find a healthy equilibrium.
In such cases, I think security patches ought to be decoupled from feature/interface changes. But honestly, I don't have a great solution.
My meta concern is that so much of UX effort is focused on moving software to meet the users where they are, rather than helping people become generally better users of computing.
I don't like that it does it suddenly and without warning, to be honest. It seems like more and more programs just update themselves by default and it's annoying when they do a big change, like Firefox's recent UI change, as the same type of change as a security update.
Sorry if this is an annoying format, but it's an interesting read on the UX experience with FOSS that l'm heavily agreeing with. Thought it was an interesting topic to share and discuss, be it on twitter or here.
Thing is; the priorities of many FOSS developers and end users may not overlap. As a linux noob l've experienced this numerous times; have fun trying to install this one package without being able to find any information on how to as everyone assumes you know that already. Same goes for the interface and UX of a lot of open sourced software; it feels like the creator thought it was unneccesary to have a good interface as apparently, in tech, you should be used to looking at a confusing mess of interfaces that look like they were made in 2001.
l've also experienced this phenomenon while collaborating on a design/tech project, where some programmers made an atrocious UI which l wanted to improve. To which they replied that it was unneccessary and the user can figure that out by themselves. Yes, technically they can figure it out by themselves, but why not make it so the user can instantly understand a program, opposed to having to spend a few hours reading the docs?
Have you experienced this? What are your thoughts? Does every software need a decently designed interface?
FOSS has a big problem with UX. Not exclusively, Windows - especially outside MS official apps - is an absolute shitshow too, although for different reasons. I haven't used MaxOS/iOS for years but it was always a little better. Software in general is not well designed. Scratch that, actually, the world in general is not well designed. So, so many things I see in the world and think "if they just did X, things would be easier for everyone".
Anyway, back to software. Obviously this isn't 100% true because there are people with both skillsets, but as a general rule software engineers shouldn't be allowed near user interfaces. They are usually the worst possible people to come up with UI.
Interface design is hard. Seriously difficult. Developers tend to forget that in part because they are the sort of people who know how to, and are prepared to, figure stuff out with brute force and experience. But also because when you've built a piece of software from the ground up, and when you've spent a large part of your life working with all sorts of software, you forget how much skill and experience you bring to using something. When I'm using my own software I don't have to think at all because everything is exactly where I expect it to be, because I put it there!
Two things I like to remember:
"Intuitive interfaces don't exist"
"There's no such thing as user error, only bad design"
'User error' in the latter context also includes people having to figure stuff out by themselves, past a certain point. One example I like to give of the certain point is Gnome Shell. "Press the windows key and start typing" is a reasonable thing to have to learn, and that being all you need to do is one reason Shell is, in many ways but not all, a superbly designed interface. If I had a pound for every recovering Windows user I've put in front of Shell and left with that one sentence and just that one sentence I'd have... well, at least three pounds.
On a UX note related to this post, I really hate reading things on Twitter. There's so much to dislike about Twitter's UX but multi-tweet posts are just a disaster area. I never know if I've actually seen all the tweets in a thread because it's possible to get lost. Heaven forfend I want to read any replies because I can barely imagine a worse way to manage those than how Twitter does it.
This makes me think a lot about what my History of the English Language instructor told me: "You can't speak your own language wrong." She was talking about the tendency to prescriptivize language use into "right" and "wrong" usage, but I think that relates to the idea that some authors think the way they use a program is "right," and if you can't figure that out as a user, that's your error. And it's really annoying, because everyone has different goals, and they're using a certain tool because it's the best one they can find. A screwdriver designer shouldn't be annoyed at someone because they're trying to hammer in a nail with it when that's all they have, and the same goes for FOSS developers etc.
I find it very ironic to discuss UX problems in a Twitter thread. Anyway, I don't think I've noticed a big difference in UX design quality between FOSS and non-FOSS.
As a UX person, I want to offer a defense of Twitter threads and argue for its merits.
I used to dislike the Twitter thread format, but I've come to understand why it's so popular over the blog post format: it's somewhere between a blog post and a conversation.
Each separate Tweet feels like the user is taking a pause to breathe. Often, a talking point is neatly contained within a tweet. This way, the audience can engage with, respond to, like/heart, and share/retweet individual talking points — which is key in our soundbite era. It's like when a talk show host delivers a punchy point and pauses for the audience to cheer and clap.
It just feels different from a monolithic blog post.
That's a good point. Someone else mentioned this line in this thread
And I think a corollary to that is that if users enjoy something, then it's good UI. Like linguistics, it's not useful to take a proscriptivist approach to UI, where you look at Twitter's threads, and say it's bad UI because you don't like it. Clearly many people, you could even say, at this point, more people, like long twitter threads over blog esque posts, and that's something that should be taken as an observation and studied, not dismissed.
Honestly, this is exactly why I get so pissed off about people complaining about UX, especially in large FOSS projects. What makes a UI "good" or "bad" seems to be extremely subjective.
From my personal perspective, I haven't ever really been upset about the UX design for any FOSS project. Like @mat brought up, there's a mountain of proprietary software that is much worse. Even FOSS software that has famously bad UX (i.e. the early versions of Blender) at least were fairly consistent in the way they worked. On the contrary, proprietary software - especially "Professional" or "Enterprise" grade proprietary software - had completely arbitrary and confusing UI as a universal constant. My boss right now is finding himself constantly struggling with an industry-specific CAD program because it forces you into a specific workflow and if you don't use the right tool in the right phase, it's not going to do what you want it to do - either because it doesn't exist anymore, or because it now does something different, or it only works on certain aspects of the design. And if you want another example, just ask any medical professional what they think about Epic systems.
I also find it irritating to hear people who complain about FOSS generally not caring about UI, when it's plainly obvious that there's a number of development teams who care greatly about them. Blender, for instance, has seen more changes in it's UI than just about any other program I can think of, all done in order to make things easier for people to get started. The same thing can be said of the KDE and Gnome projects, which cover a wide swath of software projects. And then there are projects like Krita, Inkscape, and Darktable, which have become so popular that a number of people have grown to prefer them to their Adobe Suite counterparts.
Weeeell, kinda. There are pretty well known rules of UI design. Like Fitt's Law, Hick's Law and so on. They're not subjective, they're pretty well-proven bits of science. There's been a lot of work done in UI labs to find out how various interfaces and interface elements work. I can point to various interface elements and say "this will probably work well" or "people won't find this" or similar. It's not all hard and fast rules by any means but I wouldn't say it's extremely subjective.
So I've always thought a lot of this comes down to the way desktop chrome is created. FOSS projects almost always use one or other external toolkit to actually draw their interfaces - GTK, Tcl/TK, whatever KDE's one is called, etc. There weren't ever too many options so there was always at least some sort of consistency between how things looked and that enforces some degree of consistency in how things work as well. You can still create a terrible interface in GTK but it will at least look like every other GTK interface, so it will be a little easier to use by people familiar with GTK.
Windows, on the other hand. Dear god, the mess that is proprietary chrome in non-MS apps. I don't know what underlying tools MS provide for drawing interface elements but it seems like it's much easier to style (and 'style' is a very strong word for some of the disasters I've seen) and people do. They should, generally, not do that. I've generally assumed that some manager somewhere has said "we want our app to look different so people remember it, make that button a weird shape or whatever". And it's not just in-app controls - Gnome and other window managers simply do not let apps place their window close buttons anywhere other than top left/right/whereever the user has chosen. But apparently you can style the top bar in Windows and put those fuckers anywhere you fancy. It seems like developers can break interface consistency very easily in Windowsland and consistency is so, so important. Because there's no such thing as an intuitive interface, only one the user is used to - so make your app look like everyone else's stuff and it'll be easier to use for free!
I agree with this. I don't think most FOSS projects don't care about UI, I think people are generally trying their best. But good UI designers are hard to come by and it's not a skillset a lot of software developers have. That is definitely changing though, people are much more aware of the importance of making their stuff usable.
I think enterprise software needs to be seen through a different lens because of how it's selected for use: long and involved sales processes, regulatory requirements, approvals, corporate politics, and the rest. It's often inflicted upon the end user, rather than chosen by them - so abysmal UX isn't rooted out, and in turn good UX isn't rewarded, meaning manufacturers don't invest in it.
Consumer software is operating in a world where the end user makes the purchasing decision, and that means drawing them in quickly and making their life easy, or being rapidly uninstalled. There's an evolutionary pressure towards user friendliness (and towards artificial lock in, but that doesn't usually manifest in the day-to-day user journey).
Not to say any of this necessarily challenges the rest of what you said, I just think it's relevant to keep the comparison more equal.
I see what you are saying, but the other part of that is that unless you are talking about software designed for very specific industries, there tends to be a lot of competing software. For instance, there are so many CRM applications for use in sales that it’s practically impossible for any given business to evaluate them all. The same is true for other types of corporate software like ERP and POS.
And I would argue that UX is at least as important for corporate software as it is for personal software, because in the case of corporate software there are real costs to be paid for bad UX. You have to spend more money training each employee to use it, you have to spend more on support staff to fix the mistakes people make using it, and you have to have more technical staff to help when users get lost in the software.
(That being said, the people who end up making the decision of which software to purchase often aren’t the best people to make those decisions, so who knows how much weight these factors actually receive)
Adding onto that corporate point, from just earlier this year - Citibank looses $500 million because of bad UI.
Call me jaded, but in my experience that last sentence is the killer! More times than I'd like to count I've found out that the brain-twistingly bad software is somehow the market leader even when there is a relatively well designed alternative available within the same niche.
you're right that epic has terrible UI I just want to add to that that they are also a terrible company and holy cow do I hope someone replaces them in the market.
Yes, I've absolutely experienced it. I said this about git in a discussion the other day, but it applies to Unix in general: the entire design seems to be based around taking cognitive load off of the developer and putting it onto the user. I can understand how this started when you think about computers in 1971 when Unix came into being. They couldn't do a lot of things we take for granted today, so the user had to take on some of the responsibility. But it sure feels like that got engrained into the culture of the people building the OS and has stuck ever since.
I get the limitations that were inherent in the 70s and 80s. But there's no reason, for example, that Unix commands today shouldn't handle spaces in file names. But despite that, I'm currently preparing a patch for (ironically) the "patch" command that allows it to work with files that have spaces in the name. Larry Wall wrote patch in 1986 and nobody has addressed this issue in the ensuing 35 years (at least on the BSD side of things). I guarantee that hundreds of developers and probably thousands of users have hit issues with this and each spent hours debugging what the problem was only to find that, yep, this program can't accept a normal file name. You have to take special precautions when using this tool, and it's not documented anywhere that's the case. (And these would be highly technical users, not normal end users.)
What's worse is that most CS programs force students to do their work in a Unix environment. This further entrenches every awful thing about Unix as normal in the minds of developers. It's a huge problem that nobody wants to admit or address. (And I don't mean to suggest that Unix has nothing good to offer, just that its problems are numerous and they're widely accepted without a thought.)
Even as an advanced user when I saw that VLC popup today my first instinct was to close it and just go without the update.
This was an enjoyable read! I would recommend anyone not familiar with the project to check out elementary OS, a Linux distro which (purports to) puts UX at the forefront of all of their design choices. Often to the ire of some of their more power-usery users. They have a good blog where they discuss some of their design ideas, and the reasoning behind the choices they make. It's a cool project, and they're trying to build a platform to help open source developers earn money more easily, which I am all for.
I really liked Elementary!!! It was hands down the most intuitive UX for a Linux distro I’ve tried. It was the only one I was content to stick with as my everyday OS. Something else I liked about it was that it ran surprisingly well on a really old laptop. If the laptop that it ran on hadn’t died I’d still be using it. I would suggest it to most people.
I hadn't come across Elementary, but I'm incredibly pleased to know that it exists - from a quick skim through, it's the first Linux distro that I look at and see as a stand in for macOS in terms of what I can only only describe as overall "niceness".
The Word users I know hate computers, only use them when absolutely necessary, and want their sessions to be as brief as possible. Maybe the UX should be voice transcription.
Sorry, I know this is a bit facetious and unhelpful.
EDIT: I should have made it more clear that I know this is a bad idea. It was kind of a sour joke more than an earnest suggestion.
The problem about a voice UI is that it doesn't have an easy editing layer. It is difficult, cumbersome, and unintuitive to edit something misspoken or wrongly transcribed without jumping into the graphical UI — which is what iOS does with its voice transcription: words transcribed with low confidence are underlined so users can tap them to select alternative transcriptions. (You could mix transcriptions and commands together, but it would offer a poor user experience as they get confused for one another.)
Many people rely on typing/writing because they constantly jump between typing, deleting, and retyping. There are some people write from their stream of consciousness, so they'll use voice transcription and speak aloud their thoughts and then go back and correct the transcription.
Voice transcription is the UX sometimes — when appropriate. The thing about voice is that it has:
Low (effort) activation cost — saying "Hey Siri, do this" is a lot less effort than waking your device, unlocking it, navigating to the right program/app/window, and so on.
High (effort) operational cost — continuously using a voice interface for more than several seconds can runs a very high likelihood of running into multiple bad transcriptions or technical limitations which then requires the user to repeat and/or reformat their query until it is understood and matches the system capabilities.
This makes voice UIs — given the current state of the art — great experiences for short queries ("remind me to call David tonight") but poor experiences for long queries and complex interactions.
Here's macOS's transcription of me speaking my reply:
And here's my reply as I typed it:
I believe this is the core question and that the thread kind of glossed over it by just stating that it is existing MS Word users. There's likely a bunch of existing users of the application who may or may not have similar needs and preferences. There may be a conflict between UX improvements aimed at helping new users and familiarity for the existing userbase. In addition a lot of FOSS is written and maintained by a fairly small group of people who likely work on the software to solve a problem for themselves. For those projects I think it is unreasonable to expect good UX. Or maybe whatever the creators/primary user thinks is good UX is by definition good UX.
Sure Blender and OpenOffice and a few other should be held to a higher standard. But again for those familiarity might weigh heavier than helping new users.
As an aside it is also about setting the right expectations. The UX for installing Arch Linux might be considered horrible for someone new to Linux. It is a fairly complex multistep manual process. However, you're kind of expecting this up front. That means I, as someone who wants to install the distro, know what I am getting into.
How? It's far from intuitive, you grab anyone off the street, even pull from a pool of Linux users, unless they've got prior experience they won't be going anywhere fast.
I considered, but eventually decided not to, make a comment which was at least thematically similar.
I think there are two very important aspects to the "FOSS UX" discussion (and even broader UX discussions) which are often and unfortunately glossed over, including in both the posted article, and the comment you replied to. They are:
I personally use i3 on Linux. My interactions with my computers are orders of magnitude smoother, more fluid, and more powerful than any interactions I've ever observed between a Windows or Mac OS system and its user. I assume this is what @vegai is referring to: yes, obviously if you throw someone who's only ever used Windows or a phone OS into a heavily-tweaked free software desktop, they'll sink like a stone and accomplish no swimming whatsoever; but the interfaces they are more comfortable with simply do not enable the levels of interaction we know to be possible.
I have a bunch more thoughts (and also a bunch of open questions) about this, but I think I'll leave it there, to try to foster some discussion.
While I get what you're saying, it's a little bit funny to me that you picked i3 specifically as an example - its configuration file is just about the worst of any user-facing Linux program that I've dealt with.
Right, i3 is such a high-point of user experience design that neither of your screenshots are even using it because it doesn't have basic features the creators of these screenshots desired. You do understand how requiring your target userbase to be familiar with open source software development concepts like forking, then go and reinstall the entire desktop from some other source (especially since i3-gaps isn't in any Linux distribution's repositories besides Arch to my knowledge), if they want to be able to enable basic features like gaps between windows, might make i3 a hard sell as far as general acceptance goes?
And this isn't something that would be fixed on its own just by merging i3-gaps into i3 -- the gaps situation is a symptom of a wider problem with how developers of elitist FOSS stuff look at audience and experience, and is really the same problem OP is pointing out with VLC but several orders of magnitude worse.