[felipefar]

Low UI density is the new emperor's clothes in modern UI design. It's being actively promoted by companies in order to cut design costs, but the truth is that it's only reasonable on touch interfaces or casual apps.

Mouse interfaces are fundamentally different, because you have much more pointing precision, so it pays off to show more data on the screen. You don't have to cram your interface with with spaces to make it scan-friendly, you just use heterogeneous elements and colors. Look at Blender and you'll know it can be done.

I'm designing a desktop reference manager (https://getcahier.com), and one of its aims is to provide a UI with high information density. The mobile version will be able to adjust the experience, replacing desktop-only interaction patterns with mobile ones, and the UI elements that are shared will be somewhat bigger, so that users are able to interact them with touch.

Apart from that, it seems that the whole industry is confused regarding UI styles. UI frameworks are either favoring touch interfaces and degrading the experience on desktop, or vice-versa. Even Windows 10 released certain parts of the control panel with desktop look and feel and others with touch-friendly but desktop-antagonistic screens. It's time we realize that both platforms are different and we shouldn't degrade one in favor of the other.

[jwr]

> Low UI density is the new emperor's clothes in modern UI design

I design, develop and maintain an ERP-style application with lots of tables. The fashions in UI design have made my life much more difficult over the last decade.

The problem is that designers tend to follow fashion trends. And the trend over the last decade has been "lightweight! clean! lots of space!". This is great if you are making a landing page, not so great if you need to display lots of data.

Google made things worse with its terrible UI design, which people accepted as mantra. Yes, there is lots of white. Your screen will mostly display… space. But just try using the Google Ads interface: it doesn't even fit in a normal browser, you need to have an extra-wide window just to see stuff in the tables. Not to mention they keep redesigning it, and every new update is hated by the customers, as well as by Google people (I've been told by Google ads consultants how to switch to the older interface, "which they all use because the new one is worse").

Another problem which compounds the situation for me is that designing tables is not cool. So, UI designers (and self-proclaimed UX experts) will "obsess" over every pixel in iOS-style switches that for some reason have replaced checkboxes, writing blog posts about how things are misaligned, while tables are left as an afterthought. Take a look at all modern UI toolkits: you will find very few with good tables, and likely not a single one with dense tables.

Oh, and on the functionality front: JavaScript libraries like DataTables are great for simple things, but are nowhere near a complete solution for complex apps.

[cageface]

This is because mobile is where all the money is. All the vendors have neglected their desktop SDKs to such a degree that Flutter is now in many ways the best desktop UI stack.

Even Apple has sorely neglected their desktop APIs. Play around with SwiftUI on the Mac for more than a few hours and this will become glaringly apparent.

[elschneider]

I think there is a fundamental difference depending on what kinds of users you are targeting and how often they're using your app. Blender is a prime example of software for professionals, that are also willing the spend a considerable amount of time on learning the UI. A lot of software is not targeting a similar audience and should limit cognitive overload.

[panta]

I'm constantly frustrated by software that tries to limit cognitive overload. Stop treating your users as if they were cognitively impaired. In other words, write a software that also an idiot can use, and only idiots will want to use it.

[jorvi]

I have had the (dis)pleasure of watching my 60yr old mother having to re-learn the entire administrative part of her healthcare job three times over and deeply struggle because the insurance suits decided a new software package was needed.

Nothing humbles you more as a dev than seeing a layman struggle through an interface, getting increasingly frustrated and desperate because she can’t find the button she needs due to complexity and sensory overload due to a million tabs, buttons and text fields.

The worst of it is, you can see that she knows what she wants to do, but can’t translate that into the steps needed to get the computer to “understand” that, effectively making it feel as if it is trying to sabotage her. Something that would have taken 20 minutes with pen & paper suddenly takes 40 minutes digitally. Weren’t computers supposed to make us more efficient?

Considerately, screw your attitude. Eat some humble pie.

[treyd]

Both of your and the parent's points are true at the same time.

[SanderNL]

This anti-learning attitude is common, but I don’t find it admirable.

To me this is like a dev saying “screw Git, I just want to do console.log(). All this complexity is sabotaging my productivity.”

Modern jobs, even health care, require learning about and managing complexity. It’s not just “taking care of people”. Throwing your hands up and saying “I’m old”, which is a lousy excuse because I know plenty able old people and completely digitally illiterate young people, is not a viable solution.

Now, whether we want that as a society is another topic. But for the foreseeable future adapting to complexity and actually taking the time to sit down and learn this shit is IMO the only way forwards.

[wakeupcall]

This is not anti-learning. This would be akin to git changing command names and flags doing exactly the same stuff. After a couple of times happening, even if the changes are somewhat ok, you too would start to be frustrated.

I've seen healthcare management software evolution due to my partner working with it. As in the worst management story, it's pitched to a boss that doesn't need or want to use it, offered to generally the lowest bidder, and then immediately outsourced in parts that rarely work well together taking years to develop.

The UI and workflows are designed by people that will never use it and are just plainly bad. The software/UI takes years to stabilize and reach feature parity to the same level it was before. During that time, it's pretty common to see staff having to use both systems and perform double data entry.

You're not learning to improve anything here. You're substituting a [shitty] tool with another one which does _exactly_ the same.

Sadly in IT this is pretty common. There's nothing special about healthcare.

[hk__2]

> I'm constantly frustrated by software that tries to limit cognitive overload. Stop treating your users as if they were cognitively impaired. In other words, write a software that also an idiot can use, and only idiots will want to use it.

I disagree. I’ve been using IntelliJ for a few years now, and the new, simplified interface has made my experience a lot better. IMHO you should limit the cognitive overload but enable power users to increase it. See also Wikipedia, where the main editor is basic but if needed you can switch to the code editor and/or add plugins to make the interface a lot more powerful.

[KronisLV]

> I disagree. I’ve been using IntelliJ for a few years now, and the new, simplified interface has made my experience a lot better.

I work on a bunch of enterprise projects and therefore am sticking with the old design, because having more features available at a glance while also fitting as much of the code on screen as possible is definitely nice to have, in addition to my already established habits and knowledge of the UI.

But the new UI? It's also really sleek and pleasant, and a joy to use in the cases where I've toggled over to it. Plus, the fact that they worked on adding a compact mode to the new UI is also great to see! Definitely a good experience in my eyes.

I think the trick is in giving the user the choice on what to use, if there's no horrible incompatibility between the various iterations of something. For example, the day when the old Reddit UI (old.reddit.com) stops working is also the day when a bunch of people will stop hanging around the place. The problem is that companies often find the additional support needed to be a hassle and just optimize for the majority of users, not all of them - much the same how many games out there don't even have a Linux or Mac release, even in cases where the popular game engines make having one pretty easy!

The parent comment above yours is perhaps a bit more mean than it should be, though.

[zo1]

I literally have the opposite experience as a dev. The new interface is horrible, and it's not just the layout. They subtly somehow changed the borders and their color. I now officially can't delineate and know which part of the UI is for what.

I had to fiddle with color schemes, add-ons for updated icon colors, etc. It's a mess.

And even if it's about reducing cognitive overload. The old interface had plenty of "features" and "configuration" to reduce the cognitive load as much as you wanted with both presentation mode and the ability to change the UI however you wanted.

My cynical take is that we just had two giant camps promoting this. One was the designers that wanted to have something to do. And the other camp was the VSCode pushers that just couldn't stand that a glorified (and order of magnitude inferior) text-editor is maintaining user-counts.

[Ygg2]

I'm calling bullshit on this one. In more ways than one.

1. Stuff that benefits imparied users benefits others. Subtitles help both. You'll never operate always at peak capacity either.

2. You can design UI to be layered. Easy mode for beginners and more advanced options for advanced users.

3. Software that's easy to use sees bigger audience. Period.

[llm_trw]

A bigger audience isn't a better audience.

A violin solo in a football stadium with the usual football audience is not an improvement over one in a recital room with the usual audience.

[Ygg2]

Sure, it's not worse either is what I'm hinting at.

[juliushuijnk]

Depends on your goals

[petre]

They’re the ones asking for it. Release an application with dense UI today and the clients will quickly dismiss it because the market wants to do things as easily as possible with a few clicks - instant gratification. They want a language - computer interface, like Google’s Assistant, but one that works. This is why everybody pushes AI features: the promise of Clippy doing the work for you.

[LtWorf]

That usually just results in an excessive amount of clicks to get anything done.

[asoneth]

> It's being actively promoted by companies in order to cut design costs

I'm curious why you think it reduces design costs to put less information on the screen? My experience has been the reverse -- the companies that chase trends (including but not limited to low-information-density screens and using mobile-first designs for desktop applications) also tend to spend more money on UI design compared to other companies.

[funcDropShadow]

> I'm curious why you think it reduces design costs to put less information on the screen?

The question is for whom it saves costs? For the developers of UI framework it certainly saves cost to treat the desktop as a second rate platform and to focus just on mobile.

Developers of desktop applications have to pay the price, by working around libraries and frameworks that do not consider them as a first tier clients.

[sulandor]

maybe oversimplified:

things on screen take effort. less things, less effort

[asoneth]

I've been a designer for a long time, and none of my contracts have ever paid based on the number of things I put on the screen. The design effort required to make a grid or list of data dense or sparse is pretty much identical.

(At least in enterprise software the data density typically depends on who makes the purchasing decisions. If novices and/or business folks are the ones making the pick then the software will look sparse. If technical and/or experts pick their own tools then it'll be dense and efficient.)

[dagw]

Deciding what not to put on the screen takes at least as much effort as adding things to the screen.

[stoperaticless]

I sense that you have in mind something like

> Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away.

That is the right reaction to over-complicated baroque creations.

Important to note, that oversimplification is possible. (There is point at which removal is no longer benefitial)

[sulandor]

rhetorical relation but i agree that minimalism is a worthy goal.

though, excessive white-space does not really scratch the "efficient interface" itch

[zozbot234]

Touch interfaces have less pointing precision, but more swiping precision compared to mouse interfaces. The optimal touch interface probably involves lots of pie menus and/or drag-and-drop gestures that ought to easily compensate for the somewhat increased size of initial touch targets. (Note that, by contrast, these gestures tend to be quite awkward when using mouse or touchpad input.)

[LtWorf]

Ah, the always easy to discover (only in the mind of the designer) gestures.

Let's not forget that with the current gigantic size of phones, I can actually easily reach less than 50% of the screen. The top part is completely out of reach.

[mst]

Because I tend to hold it with my left hand and tap with my right, I've deliberately moved icons around until my most commonly launched apps are as close to the bottom right corner as possible.

I've actually stopped using the 'switch between running apps' UI almost entirely now because with that done, it's faster for me to tap to the home screen then on the icon of the app I want to switch to.

[nsonha]

gestures are the time wasting way of doing a click

[shit_game]

> Mouse interfaces are fundamentally different, because you have much more pointing precision, so it pays off to show more data on the screen. You don't have to cram your interface with with spaces to make it scan-friendly, you just use heterogeneous elements and colors.

Another massive consideration is that a mouse (and a keyboard, if you want to expand from UI to UX) pairs that precision with significantly more available control actions - LMB, RMB, MMB, scrolling, and hovering.

With a mouse, the edges and corners of the screen are the easiest and most reliable areas to interact with; this is the inverse of touchscreen UIs, in which the center of the screen is the most ergonomic area of the screen to use, and edges and corners are practically unusable, leading to large margins in almost every UI targeting them.

With controls like LMB/RMB, you can also have functionality _immediately_ available wherever the pointer is located, which is now quintessential for practically all desktop applications, and which can't be faithfully emulated with touchscreen UIs.

[Eudaimion]

Is Cahier built on top of Zotero? It looks very similar.

Good notetaking support is something Zotero lacks, so I see the appeal for an alternative that focuses more on it.

[felipefar]

Cahier is built from scratch with native tech. Besides more comprehensive notetaking support, I also want to provide support for synchronization with existing cloud providers (Dropbox, iCloud, etc.).

[danielvaughn]

I should add that I think Tailwind, much as I love it, has been responsible for much of this problem. Tailwind’s creator, Adam Wathan, wrote a book called Refactoring UI. It’s a book that teaches you how to design, and one of the things it explicitly states is that you should add generous spacing around elements.

If you look at Tailwind UI, which is clearly governed by the principles laid out in Refactoring UI, you can pretty much see the blueprint behind 95% of websites today.