Hacker News Reader

Comment by hliyan | Hacker News Reader

To me, peak usability was 25 years ago, when most applications had a toolbar and a menu that followed a standard pattern. If you're a frequent, non-power-user, you use the toolbar (e.g. "insert row" button). If you're an infrequent non-power-user, you go through the menu (Insert > Row Above). If you're a power user, you remember the shortcuts indicated through underlined letters in menu labels (e.g. Alt, I, A).

If you want to change settings, you open the settings dialog (Tools > Settings), and it as tabs like "General", "Fonts and colors" etc.

Most people were a lot less computer literate back then, but they were able to use most applications with little help. If they really needed help, the help system was built into the application.

The goal back then was to have the user get the work done as efficiently as possible, in effect, minimizing the time the user pends on the application. Modern UX doctrine aims for the opposite goal -- to keep people "engaged" as much as possible. This might be okay for consumer apps, but maddeningly, the same doctrine gets applied to enterprise applications as well. I've literally heard non-techie employees of a Fortune 100 company ask for their legacy green screen terminals back because the new, flashy SPA was slowing them down.

View on HN

One of the most expensive pieces of software around is a Bloomberg Terminal, with base price starting at 20k/yr/license, plus more for extra data. And the UI, when you first use it, is beyond clunky. It looks seriously like a piece of stone age technology, adapted from clay tablets. Even the styling is like 80s films about edgy hackers and their punch cards.

Except when you talk to the grey hairs, you realize that UI has never, ever changed - it is backwards compatible back to, well, stone age of computers. It is quirky, but once you learn it, you're done for life - no refreshed new looks or skins or dark modes (well, it's always in dark mode) or rewrites in Svelte or whatever. That's basically because the power user is essentially the only user that matters. They know all the arcane key bindings and weird abbreviations, and Bloomberg knows better than to mess with it.

I hated it at first but grew to love the stability of it.

Speaking as someone who has never used it but has spent some time researching it, the Bloomberg Terminal constantly undergoes UI changes, though not in a dramatic way. It's obvious if you look at screenshots throughout the time (it even had some gradients!). It has had its own "rewrites in Svelte", transitioning from a custom renderer to HTML/JavaScript.

But you're correct - they don't mess with it, they slightly and mostly invisibly improve it, and someone who learned it in 80s could use it without problems today.

https://www.youtube.com/watch?v=uqehwCWKVVw

https://www.bloomberg.com/ux/2017/11/10/relaunching-launchpa...

https://www.bloomberg.com/company/stories/how-bloomberg-term...

https://www.bloomberg.com/company/stories/designing-the-term...

> the Bloomberg Terminal constantly undergoes UI changes, though not in a dramatic way

This is correct. (Source: I worked on Bloomberg's UI change management policies.)

Despite dismissive comments from design industry folks and more modern-looking competitors, the folks who ran Bloomberg's UX team maintained a focus on customer needs and user research. There are even a few cases where function teams went back and re-implemented old "bugs" after a rewrite (e.g. in the MSG editor) because users had adapted to the old behavior. (Thankfully nothing as bad as spacebar heating https://xkcd.com/1172 though)

> and someone who learned it in 80s could use it without problems today.

That's the true dream. Like all of those old movies where the hacker or fighter pilot has to use some foreign, alien or futuristic tech and they just use it!

I just watched a few minutes of someone using it, and I have a few observations.

- Uniform menus everywhere

- Every menu has an ID visible in the corner. Imagine how easy troubleshooting would be if you could just say, I'm on menu 4388 and I'm not getting the result I expect.

- Every selection has a number. Presumably you can type this in rather than mouse over to it?

- Every page has keywords you can string together for instant searching

- No transition animations

This is nice to see: a tool for getting things done, not for nudging the user in a desired direction to satisfy marketing goals.

My parents work for a company using an old system using numeric IDs for menus and screens. It's currently a web app, but it seems to share a good deal of code (and a great deal of philosophy) with the previous, older version, a TUI apparently built in Pascal.

I can confirm that those numeric IDs help A LOT in troubleshooting and documentation. And not only that: those IDs are frequently and naturally used by the users themselves when communicating between them. Needless to say, they also use the IDs to navigate the system, only touching the menus when they have to use some infrequent function.

I always mention this "case study" to UX folks who insist to dumb users down with childish interfaces.

> no ... rewrites in Svelte or whatever

The vast majority of the terminal interface has been rewritten more than once, but the UX framework team does a great job mimicking the prior look and feel each time. Though if you know what to look for you can spot functions that haven't been updated in a while, and even a handful that have remained unchanged since the beginning.

> no refreshed new looks or skins

Basically right, though Launchpad was completely new and PDFU COLORS <GO> provides color themes intended for folks with color-vision deficiency.

Yeah this is a good reminder that technology rewrites do NOT need to rethink the UI. I've always favored updating the technology first to enable faster incremental UI changes afterwards.

I love my UX friends but they almost universally hop on tech updates to rethink everything, and then it muddies up the customer feedback on the rewrite. Was this a tech bug introduced? Or an annoying UX change? etc.

When I taught UX graduate students we certainly tried to instill in junior designers that their chief responsibility is to their end-users. And where it doesn't negatively influence their users their secondary responsibility to the business. Coming it at a distant third is their own sensibilities and satisfaction. Putting business needs above your users makes you a black-hat designer peddling dark patterns. Putting personal sensibilities over either makes you a digital artist -- not inherently a bad thing but also not what most companies are looking for.

Frankly many junior developers seem to have missed this lesson as well. I've seen countless rewrites for personal satisfaction or learning rather than concrete end-user or business goals.

Well, it depends on the audience of your software. Bloomberg Terminal is awesome, but has a steep learning curve. Most people who learn to use it are learning it with the specific intention of finding a job where they are paid to know how to use the Bloomberg Terminal. I agree, the UI is awesome for that, but if your startup is an app to find a dog walker or something, the vast majority of your potential users are going to be turned off by the Bloomberg Terminal interface.

Yeah but even if your app is the new Uber for dogs the goal should still be to let users accomplish their task as fast as possible and not some app engagement metric.

> you realize that UI has never, ever changed - it is backwards compatible back to, well, stone age of computers. It is quirky, but once you learn it, you're done for life

True power users could customize to remove the quirks and also be set for life, but at a better level of ergonomics. Or they could even use the best customization from one of those gray beards who cared about ergonomics more ever back in the day

And none of of the cheap criticisms of skins would change it since skins for power users are optional

You fail to grasp the value of bloomberg terminal.

The UI has in fact, evolved, but it has never changed. For example, higher DPI screen sizes, the UI is now instrumented in a web browser, no longer the the old TUI. It is fast, it is familiar, it's the same, but it evolves, if that makes sense.

If you know how to use it in company A in decade 1980, you know how to use it in company B today. That doesn't mean it hasn't improved or improved ergonomics.

It's a beautiful piece of engineering that got the basics right. Power users add whatever they need to it, modular, but it's not like Vim or VSCode where you are basically useless without a large effort when moving into a blank new updated version, let alone things like the ribbon design vs the old design in office.

It's the other way around, the value of that terminal is in the information, not whatever hated UI quirks it had been stuck with since its inception, yet people keep falling for that old logic "old+expensive = great".

> it's the same, but it evolves, if that makes sense.

it doesn't, these are the opposite.

> If you know how to use it in company A in decade 1980, you know how to use it in company B today. That doesn't mean it hasn't improved or improved ergonomics.

Neither does this: it would be just as trivial to select at company B "use config ergonomic_grey_beard_1980" and continue with all your knowledge, just without those quirks you hated in 1980 that led you to change the stable defaults to a better config.

> but it's not like Vim

And in some sense in the relevant UI area it's exactly like Vim, where many bad quirks in the default config are praised by the grey beards and new converts alike.

> moving into a blank new updated version

Why would you do that instead of using your old config???

> the ribbon design vs the old design

Neither is forcing a change like this the only alternative

I worked for an insurance company for a while that was pushing their agents away from 'green screen' terminals to webapps that did most of the same stuff, the agents hated it because they had every step necessary to do quotes and such memorized and were way slower trying to navigate menus on the web.

I think to me that would be the appeal of Vim. VSCode implicitly promises this with its plugin approach. Using Ctrl Shift P for years is the sort of thing I like. One less thing in my way.

I'd never noticed that ctrl-shift-p was a thing. In gvim ctrl-p moves up a line but ctrl-shift-p seems to do page up. Do you know if this is documented anywhere?

It's not just about 'UX backward compatibility', it's the epitome of an expert user interface. If you don't know what you're doing it's near unusable but once you've mastered it the speed at which you can operate is incomparable to 'normal' software. It's also one of the few examples of this outside of software engineering tools.

> well, it's always in dark mode

So it's no TUI app that can accommodate changes to the terminal emulators color profile? I am a bit disappointed.

> backward compatible to the Stone Age

Like Emacs. And myself ;)

> This might be okay for consumer apps, but maddeningly, the same doctrine gets applied to enterprise applications as well. I've literally heard non-techie employees of a Fortune 100 company ask for their legacy green screen terminals back because the new, flashy SPA was slowing them down.

Applying general design principles without taking actual use cases into account is the worst.

A common one is putting heaps of whitespace around each cells in a table. Visually appealing, sure. But unusable if I need to look at more than 8 rows at the same time.

Agreed. Most user experience work today are done by people who ironically have little experience as a user. E.g. they will design a table in Figma, make it look nice. They may even go so far as understand that this table will typically contain 2500 rows and introduce pagination and filtering by most commonly used attributes. But if they load some sample data into a functional mock system and simulate a typical user's day (e.g. they have to wade through this table multiple times per hour, while on the phone with a customer), they will immediately realize the feel good factor of white spaces, pastel colours and high contrast icons are very low priority.

You forgot one awesome feature of those SPA: once your user finally manage to get some muscle memory in, you can push a new UI redesign so get them back to square one. Because you have to give work to do to your frontend people.

> Most user experience work today are done by people who ironically have little experience as a user

So many upvotes for this. While the provided thing might technically work, if it is clunky for the users, the users will not like it. I understand those making the thing will probably never use the thing. The problem comes when those making do not listen to those using. There have been many times where I've made the thing, but then when I went to use the thing I wanted nasty things to happen to the person that made it. I've been in some very contentious UAT rounds where I was the user and the devs refused to listen to valid complaints.

The funny thing is that a lot of those problems are known during development time, by the people who have to actually "use" the product at all times during development, a.k.a. the developers.

Not sure I follow. The situations I've built appear fine during testing during development. I go to the UI, click the buttons, get the correct result. Test complete.

The type of thing I'm thinking about is when the user does that many many times in a day, but to get to the button that is on one part of the screen which is very inefficient compared to if the button was moved closer to something else so that the UX is improved. Sure, what the dev did "worked", but it might not feel clunky when you test it once or twice. That's the difference that drives most UX<=>Dev disagreements.

Dev: but it works

User: yes, but it sux using it. it can be better for us if change X, Y, Z

Dev: but it works. ticket closed

It doesn't matter if it works while everyone hates using it. I don't care what the devs think. If the user's request is reasonable, rational, and will improve the UX, stop fighting it. This situation is precisely my experience that happens when there's no designer.

I'm talking about bad designs. Grandparent mentions Figma, this is who I'm talking about.

Developers have to work on the app the whole day and they know when a design is bad for long term usage. Either by doing manual testing, or even when automating it.

UX people dictating the designs will rely on instinct even when developers complain that a design is inefficient. Or even for visual design things like excessive padding getting in the way of making the apple useable. IME, YMMV.

If you're talking about inexperienced/unemphatic developers being in charge of UX alone: well, yeah, that will happen too.

TFA is about not having a designer. If you have a bad designer, then fix that glitch.

Once again: grandparent post says "e.g. they will design a table in Figma, make it look nice", so I was answering in that context.

Reading about whitespace on tables infuriates me so much.

At a previous job we had an actual good designer figure out what users wanted and she found out users wanted denser information. So she designed a more compact table. It was quite smart, used the whole screen, but still looked amazing and didn't feel cramped.

Then my company released it as a library for the whole company to use and the first thing one of the product managers did was requesting margins AND frames around it, plus a lot of whitespace between cells.

Now instead of displaying around 25 items on the screen at a given time, this other system can only display around 10.

The cherry on top: it looks horrible with the frame and with the unbalanced margins.

I worked on a couple of internal frameworks as a designer and thats exactly what happened to our frameworks.

Throwing away all the research and optimization out of the window for one unnecessary “we really need this” scenario.

> Visually appealing, sure.

It's not even.

At all times, people that are proficient at a green screen terminal application will prefer it to a web based or GUI based experience. They have muscle memory and a lot of codes memorized to switch back and forth from screen to screen extremely fast and exactly how many tabs to hit to fill out a form. It has nothing to do with SPA or whatever is currently new and flashy this has been going on for decades. The fact they have to remove their hand from keyboard to mouse pretty frequently is the biggest productivity loss, then drop down boxes and forms that aren’t very keyboard friendly and the page render times are incredibly slow in comparison.

I myself made this complaint a few times. When I was using medical erp once then again using a banking system. Both you could navigate by typing a chain of commands that would register even if you typed faster than the screens would render in the terminal. Hell, in the banking one I completely automated my job by writing an excel macro and sendkey commands to the terminal, then I sold it to the bank for a small sum after I quit (they asked me how I accomplished so much after realizing 3 people couldn’t handle my workload)

> Both you could navigate by typing a chain of commands that would register even if you typed faster than the screens would render in the terminal.

Nowadays even the login screen in Windows can not manage it anymore. Gotta wait for some animation and whatever it needs coming back from sleep mode before it starts registering keys.

You could still do this in the GUIs of 25 years ago, you'd just memorize the keyboard shortcuts and use them. They'd buffer so you could type a series of operations faster than the screen could render them, and basically every function was accessible from the keyboard. But the GUI had the advantage of discoverability - if you didn't know the keyboard shortcut, you could just work your way through the menus and find it.

While possible, the uptake/usage is very low once it requires lots of CTRL / ALT / CMD button sequences. Take something like Excel, which many users use daily for work, but most people likely only use less than a dozen common keyboard shortcuts. Practically nobody navigates the ribbon with their keyboard.

I'm in a role of Finance / Excel "super user" in my profession. There's a subculture of keyboard shortcut enthusiasts, but generally everyone is using their mouse a lot. I myself have about 20 that I use and rarely incorporate a new one into the mix, it has to be an action I perform repetitively for me to care enough to memorize seek out and learn the shortcut. I find navigating the ribbon usually requires too many keypresses and I instead have a custom quick access bar that I put everything I want access to so I don't have to toggle differing ribbons, I still use my mouse even though I know I could use my keyboard. It doesn't feel easier

> Take something like Excel, which many users use daily for work, but most people likely only use less than a dozen common keyboard shortcuts. Practically nobody navigates the ribbon with their keyboard.

Partly, this is because:

- Excel has high latency to enter keyboard-access mode. Type too fast, and it misses keystrokes.

- Excel's ribbon keystrokes change depending on size of the window, and how much stuff has been added to the ribbon by VBA in the workbook, an add-in, or the user

- To a lesser extent: some of Excel's ribbon keystrokes "make sense", but some bear no relation the the target item even if a "sensible" keystroke is not already claimed by another target.

But it’s true that the menu systems often made the accelerations and afterthought, and regularly used functions for some people had no shortcuts and no way to set them.

I still think a World of Warcraft style action bar, user configurable and multilayered, would work just fine for power users. You can put anything you want in position eight but most people have the same things set for 1-5.

That's funny. I automated a lot of my tech-writing job in the '90s with expansive macros written in WordBasic. What a great product.

I agree with this, so much so that I wrote a long essay about this

Modern web design has completely lost the design idioms that so much thought went into during the desktop software wave of the 90s and early 2000s. This is a great loss for usability.

https://loeber.substack.com/p/4-bring-back-idiomatic-design

Not just web design. Design, period. Here's what Apple is producing these days: https://x.com/dmitriid/status/1899392713323147633

That is most likely what their iOS & macOS design language will be going forward: https://www.macrumors.com/2025/03/10/ios-19-visionos-redesig...

With that said, the design sins it commits are pretty standard in the age of minimalist/flat UI. It looks pretty similar to Apple's current design language, just with some stylistic tweaks.

Not defending it, as some of those design decisions drive me up a wall. Is this text a button or just an input field? Can I click this image or is it static? Which directions can I swipe? Does this grey text mean it's a disabled button or placeholder text on an input field?

I am not nostalgic for the blocky, grey, in-your-face design of classic UIs like Windows 98. But sacrificing functionality and discoverability on the alter of pretty design is, unironically, bad design.

> But sacrificing functionality and discoverability on the alter of pretty design is, unironically, bad design.

The irony is that it's not even pretty a lot of the time :)

> To me, peak usability was 25 years ago, when most applications had a toolbar and a menu that followed a standard pattern.

Some things were good, but there were lots of problems too like features hidden behind right-clicks, not knowing if you had to double or single click, being required to read help/manuals to find features, too much jargon and technical language, and overuse of modals.

UIs have got incrementally better in lots of ways that really add up that I don't see people mention e.g. right-clicking and double-clicking is avoided, help is integrated into the UI where you need it, inline editing vs modals, options to edit an object appear next to it (locality) rather than you having to hunt in a menu, less technical jargon where appropriate, better onboarding, better undo/redo/autosave (which avoids clunky confirmation modals).

> Some things were good, but there were lots of problems too like features hidden behind right-clicks, not knowing if you had to double or single click, being required to read help/manuals to find features, too much jargon and technical language, and overuse of modals.

I dunno… all of these issues are still very prevalent. The one that probably disappeared the most is the right click context menu, which I would argue was actually great for discoverability. Personally, I lament its demise. Of course context menus still exist, but it used to be a pretty reliable universal convention.

Right-click is fine for power users and professional tools if there isn't a better alternative, but right-click (and long tap on mobile) is super undiscoverable because there's no indication or hint it'll do anything.

Whenever I help non-tech friends with software problems, I'm always reminded most people don't feel comfortable hunting around for functionality and for sure don't try right-clicking things on the chance it might do something.

I know what you mean, but my point is, if you have a strong convention that right click

a) never actually runs anything, so you can’t accidentally break stuff

and

b) usually shows contextually relevant actions

That makes for great discoverability, actually. Discoverabilty is mostly a measure of how confidently one can dick around without causing accidents (and being able to undo them easily).

Your point about there being to indication whether something is clickable or not applies to left clicks just as well, and this also used to be less of a problem before everyone rolled their own, usually very flat, designs. You could teach someone basic principles and they’d be widely applicable. These days you’d have to start with a full lecture on the differences between web apps and “native” apps and natively packaged web apps…

I wonder if it took the shinier, less conventional UIs to get all these “non-tech” people to use computers in the first place. A dilemma, because they would benefit from boring conventions the most.

> right-click (and long tap on mobile) is super undiscoverable because there's no indication or hint it'll do anything.

I really miss the days where it was common for tap-holding on any control to show a description of what it is. It may still be common in certain Android apps but I haven't seen it or anything like it on iOS.

> tap-holding on any control to show a description of what it is.

Hmm, haven't seen this. Where do you need that? What kind of description that wouldn't be obvious from looking at the control?

> Hmm, haven't seen this. Where do you need that? What kind of description that wouldn't be obvious from looking at the control?

I most commonly see and also appreciate being able to tap-hold on icon-only buttons to learn the text label that the icon represents. I can usually guess what most icons mean, but sometimes it's not entirely obvious.

> UIs have got incrementally better ... e.g. right-clicking and double-clicking is avoided

This is like saying, that cutting someone's foot, makes him a better man.

Today UIs are crap. Why is the scrollbar so small and hidden ? What is all the unusable space in Office's 365 title bar ? Why gray on gray ?

The root cause is that web browsers were designed for document delivery but are used for building application UIs. The browsers don’t offer a standard set of common application UI components, so every team builds their own leading to inconsistency and half baked implementations.

In contrast, when you build a native app, developers can draw on a standard set of OS provided UI widgets.

I think the root cause goes deeper than that, and has to do with economic incentives. Up through the 90s, the predominant business model was you sell a product, people use it to get work done, if they're happy they tell their friends and you sell more product. Starting in the 00s, the business model became you give a service away for free, get people hooked, make them so dependent upon it that they can't look away, and then either jack up prices to extort as much money from them as possible, sell advertisements so that other people can do the same, or sell their personal data so that other people can target them with sales pitches. Actually getting any work done became secondary to making the transaction happen. This applies just as much to enterprise software as consumer software, because the purchaser of enterprise software is usually some IT department, purchasing department, or executive who doesn't have to actually use the software, and they will probably move on to the next company before the consequences of their purchasing decision being useless become visible.

We are reaping the consequences of that now, where lots of transactions are happening that don't actually make anyone happy or productive.

But you can see how that would filter down into UI design. When your incentive is to make people happy and productive, you spend time studying how people actually use the product, and then optimize that so they can use the product more efficiently. When your incentive is to turn people into mindless consumers that keep coming back for more ads, you spend time studying what sort of content holds the user's attention, and then optimize that so you can work as many ads into the stream as possible without them turning away. When your incentive is to sell enterprise software, you spend time studying what sales pitches will get the budget-holder to open their company's wallets, and then optimize the sales funnel to the extent of actual product usability. Even if your users hate you, they don't get to decide whether they keep using you.

Developers always had the flexibility to create custom UI elements/colors etc even in native apps (albeit not as easily as using CSS). Even in SPAs, most UI elements follow the same style or pattern more or less (bootstrap/tailwind etc). It's the entire UI design itself that's not user friendly for enterprise/business apps (excessive padding, comically large UI elements etc).

Wouldn't say it's the root cause, but it is a major cause. I have some experience developing desktop applications using Visual C++ / MFC in the early 2000's. I still prefer that development experience to modern React/Redux SPA development.

OS widget libraries aren't always big enough to solve all problems. On the web, there are many frameworks that provide widgets for typical use cases.

But even if you have a library with hundreds of widgets, you can still make a terrible UX if you don't understand good design, and many programmers don't.

In my experience most designers don't know what UX is. They think their job is to make it look pretty. If it needs 3x more clicks to do the same thing as before so be it.

There's more consistency in UIs on the web than desktop IMO

People have less power on the web so it has more limitations, even if it lacks a number of consistent UI components baked in.Desktop apps are notorious for getting fancy. Even simple control apps from random headphones/keyboards/music gear/etc all want to reinvent the settings page and make it 'sleek' instead of usable.

And controls were demarcated as controls, not disguised as plan text or a decoration. You could tell if a function was activated by looking at the outline of the button; if the "bevel" shadowing went inward, the button was depressed and the function was on.

"Flat" design is simply derelict design. Fortunately there has been some backlash and we might be returning to legitimate GUIs.

>To me, peak usability was 25 years ago, when most applications had a toolbar and a menu that followed a standard pattern.

I've done different sorts of tech support since grade school and people always ask me how I got so 'good at computers', I they never believe that actually reading the menus is 90% of it and that once you learn the common ways programs are arranged and some common shortcuts you pretty much know how to use all of them.

Good old times :) I miss F1 help, which was usually very good and contextual. On a Settings dialog? Press F1 to view help just for that dialog - offline, instant.

For me, Norton Commander specifically, among other TUIs, was very influential in shaping my keyboard shortcut preferences. I used to rely heavily on Function keys; both for lightning fast file management, and also for code navigation and debugging.

One definite UX improvement over the past 25 years have been command menus. In the most simple implementation, press Ctrl+P start typing to filter a list of commands down and hit enter.

If only this worked properly in Excel! It has them, via Alt-Q, but there's always a delay before it activates. And you can't just press Enter to accept the first result, like most type-ahead command menus; no, you have to arrow down once, or Excel stares blankly at you.

> press Ctrl+P

... and open the Print dialog. /s

Exactly the reason I still write most of my code in emacs. I’ll use visual studio when I need to do GUI work, but I feel like I’m at a casino with a thousand flashing lights all vying for my attention. I also find swapping back and forth between keyboard and mouse to be a slowdown. I know some of the VS keyboard shortcuts but find many of them to be more convoluted than emacs (and I won’t even comment on the VS faux emacs bindings!)

Luckily I spend a lot of time building libraries, where I can keep my hands on the keyboard and focus on the problems I am trying to solve

those menus started to slip a long time ago. they got larger, less organized, and got lazier about mentioning the keyboard shortcut. the new MS paint does a good blend of that style and a newer look

the current text editor trend of having a "command palette" is pretty nice. it's got a hard job to do, with the sheer number of commands and extensibility to add more, but search is pretty good for discoverability (as long as people name/tag/describe the commands well)

Ok well a lot of that UX depends on hover states and right clicks that don't exist for touch screens. Key bindings? What keys?

That's the major reason we dont have the same toolbars. We can be cynical about engagement and free software but try to make a mobile app the old way. You can't.

”Modern ux” can be a very political term on HN.

Yes, uxers have to balance business and user needs. That is the power dynamic of business we live in, it’s not typically the driving force of actual uxers themselves.

At the core the ethos of the human centered design (HCD) is being an advocate for the needs of actual users. Being seen as the ”enemy” on HN feels demoralizing, as a person that sits on both sides of the fence.

I feel gladness about seeing the truth of my experience about this. I would like there to be more camaraderie between uxers and developers, and of course it being a more common scenario to be able to drive a genuinely shared vision also with business leadership.

If you have a source for ”modern ux doctrine”, i’d love to hear about it to have an actual discourse.

> uxers have to balance business and user needs.

What does this mean? It seems that compromising the UX for a "business need" is just lazy user experience design.

The UX designer doesn’t have absolute authority. Typically, they need approval from PMs and other stakeholders, which is where the need for compromise comes in.

> Modern UX doctrine aims for the opposite goal -- to keep people "engaged" as much as possible.

In many larger orgs, usually design doesn’t work in isolation. Some of these goals like engagement, retention come from senior leaders of different functions. The design proposals are evaluated and signed off against these goals.

However, when these designs and flows appear on platforms like Mobbin, they often lack context about their design rationale. This can create a network effect where other designers replicate similar designs for their own experiences without fully understanding the underlying reasoning.

True. The UI of the applications from the late 90s to the early 2000s was way better than it is now - especially when you compare it to what is there in the web apps now.

Besides keyboard shortcuts, the following capabilities haven't really been implemented in web apps:

- Context menus

- Macros and the ability to record macros and create your own shortcuts to these macros.

- Terminal prompts built into applications such as in Autodesk - in some senses similar to the REPL in Clojure but built into the application

The problem here is the fact that the expected cost of software has become zero. 25 years ago most productivity apps would charge money. There might be a free trial but you need to pay for it. These days most expect software to be free of charge. A lot of the regression in software quality and usability can be traced back to this.

Are there any Bloomberg Emulators or similar to mess around in? Essentially the equivalent of Lemmy to Reddit.

I desperately miss keyboard mnemonics.

yes, IBM's CUA wasn't that bad. 'F1' for help is one remnant of this.

(https://en.wikipedia.org/wiki/IBM_Common_User_Access)

> This might be okay for consumer apps, but maddeningly, the same doctrine gets applied to enterprise applications as well

I think this is a great point. I was consulting with a customer and their key goal in a complex system that had a time-sensitive user workflow was "minimise clicks".

I said to them that that makes sense, but saving 0.5s on a click every two hours is not as impactful as (insert example of a change that would speed up the workflow by 10 minutes every two hours).

And it's as you say: they come from the consumer world, where minimising clicks keeps customers involved. But it's not the only thing to consider.

Reply on news.ycombinator.com