When I first started my role as Bug Admin for Inkscape’s Bug Accelerator Program (BAP), I remember everything being summed up in one simple, easy-to-remember statement: “Just make sure it doesn’t suck.” Put another way, “Make sure what we’re giving to our users/putting in front of people doesn’t suck.” Those words have been playing in my mind ever since, and with good reason, though the good reason has nothing to do with the role itself. “Just don’t make it suck” should be the motto of just about every human-to-human endeavour, whether that be public or private services, software, food, household appliances, conversations, you name it.
The more I reflect on this simple, unofficial rule, the more I realise how much of the world around us could be better if we just took a little time for a little consideration sometimes. In a digital age, does an application to an institution need to take 3–5 to... God alone knows how many “business days”? Or have we just held on to unnecessary notions of arbitrary delays because “It used to be like this when we couldn’t do any better”? Do we need to sign 50 papers and sacrifice an innocent creature just to say “I live here, I’m qualified to do this thing, and this is the contract between us that’ll do it”?
Or have we created needless friction because friction feels like accumulated value?
In other words, life and the systems that keep it turning don’t have to suck just because we couldn’t be bothered to change them. If we follow this rule, life becomes so much smoother overall, because all those little wins pile up just as much as little annoyances and obstacles do.
This principle applies as much in everyday life as it does in software. Speaking of the software side of this, though, let’s look at where this becomes relevant for a bit before bringing it back around to life in general.
Tech Insight: Why software shouldn’t suck
This might all seem like some jaded rant or just another of my typical musings on systems, software, life, and how we can do better if we just take some simple steps (something I’m working to apply in my own life in various areas). Yet, it goes much deeper than this when you zoom out for a moment. To ensure that things don’t suck is to care for ourselves and our fellow human beings. I’ll be the first to admit I don’t get this right, just as often as I complain about the systems and people who, like me, royally screw it up. But we can do better if we put the work in.
The perspective problem
When you really take the time to think about this subject, it might seem like it’s a bit of an impossible ask to make things “not suck” for everyone, because everyone has a different perspective and different needs.
From the standpoint of perspective, let me give a quick example of how real this is. I learned some years ago that no two people have ever seen the same rainbow (or sunset). No, really. Never, ever, in the history of mankind has this ever happened. But why?
Both phenomena are dependent on light and individual perspectives interacting. So, unless you can literally be that other person, in the same physical space, with the same conditions (mental, emotional, physical, and otherwise), with the same history, including the experiences that shaped their brain, you literally CANNOT see what they’re seeing. But again, why?
Well, it just so happens that much of what we experience as vision is not simply what our eyes actually see but how our brains process what we see.
Likewise, since we’re all giant, individually unique, chemical and quantum reactions (with a bit of metaphysical consciousness sauce thrown up in there), we all have different needs. Literally, not too many people on the planet ever have exactly the same needs. For this reason, it’s impossible to genuinely completely satisfy any two people with the same set of provisions. Well, at least not unless you narrow the scope of what amounts to actual satisfaction. We have to meet in the middle somewhere.
How do we get there?
Simply put, by listening, and having heard, acting on what we now know. This is especially true when we turn the lens of user experience toward the problems faced by software and tech in general. Face it: you can’t please everyone. But you can please a lot of people if you’re willing to give people a few things: reasonable defaults, sensible options, and accommodationary compromises.
Sometimes less is more, sometimes it isn’t. The goal isn’t to have less OR more. The goal is to make sure that whatever it is that you have is serving a purpose and makes sense for existing and needing attention in the first place. And whatever you don’t have shouldn’t be something that ought to exist, but doesn’t simply because you couldn’t be bothered (or humble enough) to make it so.
Does every app need preferences? Probably not. I mean, I sure don’t use the preferences on the average calculator app.
Yet, lo and behold: They exist:
Using myself as an example, I didn’t even notice these preferences existed, because I never need to use them with what I typically use the calculator app for. However, with the number of additional features that the app does provide, it makes perfect sense that there would be a need for some sensible options, not just sensible defaults. Still, those sensible options themselves represent a reasonable compromise.
Running the calculations
The calculator app doesn’t need to suddenly become a tool for predicting the stock market or connecting to your bank to balance your budget, but it does need to have some handy tools that can be of use when doing those very things. If it didn’t, from the perspective of the person who’s trying to run through some quick currency conversions while working out international transfers, the app might very well suck, because why can’t it just be “normal” and do what they need it to do?
And that illustrates the point I made in this Mastodon post recently:
I really think this is the underpinning principle of a generally “good experience”. Identify what it is that others are experiencing, what they’re interacting with the most (or at all), and see how you can make that experience better. No need to keep chasing the proverbial white whale of perfection. White whales exist in real life (rare as they may be), but in software, you’ll be hard pressed to find even the simplest of apps that doesn’t have its solid cadre of haters.
But if you pay attention to those apps that have become roaring successes in their fields of interest, it’s usually the app that happens to make people feel the most comfortable in whatever it is they’re trying to get done. Sure, familiarity is often a key factor here as well, as is popularity, and you know how I feel about those being used as criteria for “good software”.
Still, I have to be fair and say that there’s a reason why people often complain that otherwise powerful applications “suck”, even when they’re free. It’s often not that the software isn’t capable of accomplishing what they need, overall, but that getting to their desired result is functionally difficult or frustratingly designed.
So that’s the key
We can make things better, literally. We can make better software by making software better (than we do right now). A simple process shift is the solution. We don’t need to fix everything, because not everything needs to be fixed. Yes, I know I’m doing a lot of wordplay here, but don’t miss the point. For software to survive, we just need to identify and resolve the issues that make the experience suck. And you know what, it’s really not that hard. We just need to be intentional.
And really, this isn’t just about software. It’s about how we approach everything we do, especially when other people have to live with the results of our decisions. Whether we’re building an application, providing a service, or simply interacting with the people around us, a little consideration can go a long way toward making someone else’s experience better. We don’t have to get everything right, but we can at least make the effort to get fewer things wrong.
Just don’t make it suck.
Practical Tip: Fix one little annoyance
Think of one thing that regularly makes life unnecessarily difficult, whether for you or someone else. Ask yourself what you can do to make the experience better, then act on it.
It doesn't have to be a major change. Sometimes the smallest improvements make the biggest difference.
If you want to stay in this lane
I’ve written some related articles in this series that you might find interesting if you liked this one:
-
A people-first look at software design, usability, sensible defaults, and why reducing friction is just as important as making software functional.
The Unseen Price of Software: Attention
Why attention is one of the most overlooked costs of software, and how unnecessarily frustrating experiences consume more of it than we often realise.
The Myth of the Learning Curve
A look at the relationship between familiarity, usability, and the effort we invest in learning new software.
The Bloat Tax: Big Downloads for a Thin Experience
Why adding more features, complexity, and resource requirements doesn't necessarily result in a better software experience.
Working with us
At RolandiXor Media Inc., we blend design and open-source thinking for our clients.
Elsewhere
- Mastodon: mastodon.social/@rolandixor
- Threads: @rolandixor
- X: @rolandixor
Support this work
If this writing has been useful and you’d like to help sustain it:
→ https://ko-fi.com/rolandixor
Catch you in the next Roll Out!
Comments