When dealing with users, and slow processes (that you can't make faster for some reason), it is often necessary to "debounce" user input. Whether that is graying out a button, displaying a loading popup, or something else is entirely situation dependent. Whatever you choose, you should be preventing people from annoyance clicking their way into trouble.
The amount of software that doesn't seem to get that is rather surprising.
That is the worst way to debounce, because it adds 10ms latency for no good reason. The better way is to act immediately but ignore further inputs for 10ms. You might also want a little bit of analog filtering to improve EMI tolerance, but that shouldn't add more than 1ms latency.
If you have exceptional resources you may choose to not debounce at all, but for applications with latency behind it, it can make more sense to just wait for the user to signal they are done.
I believe the general concept is called hysteresis(1). Many systems require some prior state knowledge before acting to avoid cycling near the setpoint. As you said, the simplest solution is often a deadband around the setpoint so that action can never result in a state requiring action.
Hysteresis is what you add to the sensor in order to debounce. The bouncing effect itself is not called hysterisis, and does not require the system to have any memory - you get it as soon as there's noise in the measurement, which there always is.
Denouncing user input in UIs is indeed something you should do. Especially if it would be bad if the user input ends up triggering something twice.
The reason is that these systems all require realtime design techniques, and realtime design techniques are rarely taught in school and the overwhelming majority of software engineers don't know them, and the vast majority of software engineering managers are unaware that realtime design techniques even exist.
All computers that manage user interfaces today -- all of them -- are by many orders of magnitude fast enough to provide near-instantaneous responses to user inputs if programmed with realtime techniques.
The default latency of a Rockwell Panelview Plus screen with their FactoryTalk software (the dominant HMI system in North America for custom automation) is 1000 ms. Fixing that solves 80% of the complaints I encounter.
https://i.imgur.com/gEBAA28.png
(Unfortunately, it's a dropdown selection list with a limited set of values of 0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 60, and a whopping 120 seconds).
> Maximum Tag Update Rate: Specify the maximum rate at which data servers will send data to the tags used in the display, including tags used in expressions and embedded variables. The default update rate is 1.0 second`.[sic] If the update rate is changed, the new rate will not take effect until the display is closed and re-opened.
And it's worse than that - often, response time is on the order of 3 seconds, as described here:
https://theautomationblog.com/when-factorytalk-view-displays...
> Well, if you press the button just after the update occurs, you’ll have nearly a whole second go by until it’s read. And once it’s read and sent to the PLC, you’ll then have close to another second until the screen updates again to indicate its on.
I set most of my displays to 0.25 seconds or 0.1 seconds if I can, 50ms is not achievable because Rockwell's Ethernet/IP fieldbus protocol is terribly inefficient and the update rate is a polled refresh of every tag on the screen, you can't have fast buttons and slow production history string arrays.
You're saying people evaluate and react to checkbox feedback faster than 4 times/sec? I'm not a UX person so this claim seems laughable. I might believe twice that as beyond reasonable, but there is no way the average person waits less than a quarter of a second before assuming their input failed and duplicate the effort. One can hardly even observe and process that quickly - even when paying attention.
There's been plenty of research for decades showing that 250ms response time in UX is a noticeable slowdown.
Except that there was a bug where if you go too quickly, some of the software safety interlocks didn't work right, and they had removed the hardware safeties in the update from Therac-20.
Most premium Android phones in 2016 were 120-30ms motion-photon response time (low to midrange probably hit 250), while iPhones were ~80ms. Haptics add another ~30ms delay. There have been massive improvements since 2016, as it has been a competitive metric, but even with >120Hz screens sub 60ms max true latency is uncommon.
As (actually my long term memory of) the MS video shows faster refresh and lower latency greatly improve smoothness and are useful for moving objects, especially scrolling (though tearing is a real issue). The problem is much more pronounced in VR/MR as eye tracking of diagonal motion is VERY discriminating. That's why they shoot for >240Hz refresh rates. Over 1kHz there doesn't seem to be a lot of improvement (2ms latency) due to a combination of cone/rod/neural filtering.
If you want a very generic worst case latency calculation based on the touch acquisition rate and display refresh rate assuming no position calculation delay it is:
Latency = 2/Ftouch + 2/Fdispl = 2/16Hz + 2/16Hz = 250ms
Please provide a link to your data and analysis.
Seriously, I hope you don't work for a major touchscreen supplier. A good UI can deal with relatively high latency input, a bad UI can make any latency unusable. Finger motion before/after contact and rapid high force contact bounces are common problems. Many high performance interfaces "gracefully" degrade report latency to similar levels under high interference conditions.
I'd also note that under video review people are notoriously bad at actually knowing how they interact with a touchscreen. Interestingly, fast response rates (and tactile response) reduce user complaints about proper operation even when UI errors remain constant. The users often assume they made the error rather than the machine. There are also interesting cognitive load effects.
I once accidentally ran a washing machine at 90C temperature because of high-latency touch controls. I instinctively double-pressed the touch surface to reduce temperature because I thought the first touch hadn't registered, causing it to wrap around back to maximum. It did some minor damage to the clothes before I noticed. And that was with more like 200ms latency, not 250ms.
Latency on touchscreens is more important than with physical controls because there's no tactile feedback. Even 10ms is obviously imperfect for drag controls. Microsoft Research published a demonstration video:
https://youtube.com/watch?v=vOvQCPLkPt4