Toasts should be used if there is no direct relation to or interaction with a visible UI element: notification, heavily asynchronous processes, out-of-view modifications.
ETA: If they actually behaved like that, it would help with OP's issue with them-- pop out of "the toaster", where you clicked to initate the action, so you'd be more likely to notice. Seems his complaint was in large part that they appear somewhere else. (So they're not really "toasts": At least my toaster doesn't have a teleportation function, to make the toast appear wherever the toaster designer has more or less randomly decideded it should. It just pops up the bread in the same old boring position where I know to look for it.)
I'd speculate that their overuse comes from convenience of displaying any message by throwing in a `showToast("Foo!")` opposed to altering each UI component to show the relevant feedback.
That cuts both ways IMO. At least with a toast system I know where feedback appear on a per app basis (or website or whatever). Imagine if every screen, view, list entry, checkbox had its own way of displaying feedback. It would be an enormous amount of overhead.
Strongly agree. I guess toasts work better for mobile screens as they are smaller and mostly vertical, so the element spans the whole screen width. If it needs to be there and should be responsive, I would prefer it to be an alert in the upper-right corner of big screens.
Toasts are bad UX for an app which is used in a casual context, yes. The odds that an untrained user missed them and becomes confused are quite high.
But there is nothing wrong with a toast in a pro app. The pro user will get used to where feedback comes from on the screen and find it is second nature to notice the toast.
In practice, there are very few UX principles that generalize across every interface.
The pro will train himself to whatever good or bad thing you'll throw at him. The point is not about identifying generalization that works everywhere, it's just to have enough care for making the good choices at the right places.
Just because somebody will put up with it doesn't make it a good choice. That rationalization has been used to justify a lot of awful decisions and awful software.
I will say as someone with a limited visual field, toasts are very frustrating as they're almost always out of my field of view. Please keep indicators/notifications close to the thing that caused it.
Do you have a video or screenshot of this? I don't daily drive a mac so I'm having trouble recalling (I also am not sure what you mean by saving a document, in which context?). But regardless, I don't think a toast would serve me better there, that doesn't mean that ux doesn't suck either :)
Saving, when instant, does not need to notify the user. Not every action needs to notify the user.
As seen in the article, do we need a notification following a click to every checkbox? In most cases, the user should assume that the action is completed the moment it's taken. If not, you can add an inline loader and show a regular, maybe modal error if it happens.
"Save" actions, with the exceptions of large data, does not need further UI. Particularly the circle should be seen as a marker of the current state, not as a way to tell whether your action has completed successfully, so you shouldn't view it as a "10x more subtle notification"
Classic. People that are bad at UX design using the “pro app” catch-all to justify all sorts of bad decisions.
I spend all day in “pro apps”. I am also visually impaired. The inappropriateness of toasts has nothing to do with my familiarity with the app. I may, eventually, learn that a particular UI is using toasts to indicate something. That doesn’t suddenly make it okay. They’re still a massive pain in the ass for me. They’re still a massive pain in the ass for a lot of people. They’re still a poorly thought out holdover from the days of 640x480 displays, and with a modern resolution they’re even less appropriate.
You have also used a catch-all, but yours was personal and rude. The rest of your point is useful…just please remember that there are real people typing words into this app.
To respond to your point,
(1) is it a PITA because it’s hard to see something in the periphery or for some other reason?
(2) Is there an example of a web app that you’ve noticed provides feedback very well?
(3) would you consider a toast acceptable when the UX designer doesn’t consider the information critical? As in…the user can safely assume their action was accomplished but a little feedback is a nice sugar.
> bad at UX design using the “pro app” catch-all to justify all sorts of bad decisions
No, pro apps actually have completely different UX requirements.
In a pro app, the UX requirement is to be able to perform actions QUICKLY and RELIABLY, meaning it works the same way every time with a minimal number of steps.
This leads to "cluttered" interfaces with lots of information, because this way actions can be performed quickly AND results/data are always in the same place so it's reliable. Take an IDE with multiple panels with output going in/out. Quick to see what you need to, everything is sectioned off so you know right where to look, and everything is one or two clicks away.
However, casual apps have almost opposite requirements! They need to be non-intimating and simple. Simple is at odds with quick to use IF the use case is complex. Simple and quick to use can ONLY coexist in a scenario that is simple in it of itself, i.e. not a pro app but a simple app.
I actually think the opposite. Toasts in my professional tools are even more objectionable to me. They're never where I'm concentrating, and by the time I realize one is happening and look at it, it's either already gone or is saying something trivial.
The end result is usually that I've been distracted for no reason.
I don't think that's a convincing argument unless you are a tiny company that has to optimize for development time. You can also wonder why the frameworks you are using make this hard, because it's a pretty common to want feedback close to where the action happens.
In my experience the overwhelming majority of teams out there are understaffed (especially when it comes to good and productive professionals) so your example is the rule, not the exception.
I don't know anyone who isn't optimising for development time in some way. That said, most frameworks don't provide any worthwhile error handling infrastructure, and it's a problem.
In a Jetpack Compose app I wrote, I created generic "error barrier" components, so that error messages display over relevant parts of the app, with just a few lines each time, timeouts included. I think this is the best approach, easy for developers and informative for users. Too many apps just ignore errors.
I meant optimizing for developer time over usability in the context of the story, that mostly shows products from Google. Google being the opposite of a small development team that could be forced to choose developer time over usability.
The solutions seem to rely on a user that doesn't navigate before the action is completed. Does he propose locking the UI in the meantime, or to optimistically show the user a success result?
Came here for exactly this, the post is proposing a solution while only understanding one half of the problem.
Toasts are a global UI feedback mechanism for non-blocking/fallible/undo-able actions. That does make them out-of-place by default, but at least consistently so.
A solution I'd accept is local-view-first with toasts-as-fallback when the view is dismissed. That said, loading indicators _might_ make users hesitant to dismiss a view.
Debouncing is a known development tool for most non-immediate actions. It's related UI concept of locking individual UI elements is also well understood by many users (not by that technical name, but by "it's working on my action" kind of understanding).
> optimistically show the user a success result?
I don't particularly like React, but this a core feature of such JS frontend frameworks, optimistically "succeed" while async network and back-end work happens to give the illusion of speed: https://react.dev/blog/2024/04/25/react-19#new-hook-optimist...
Is this an LLM? :) The question was rhetorical. Both of these proposals have problems. But the main issue is that the author of the article is missing an angle of toasts as a UX concept.
From my perspective there was nothing rhetorical about that question as I occasionally encounter it as a serious thing. Some colleagues really do not want optimistic UI events. Some swear by them.
I don’t have any strong feelings one way or another as long as there is proper inline feedback.
My main complaint is that on Firefox on Linux anyway they actually steal the mouse position along with keyboard focus. So if you're using something like instagram's IM it's really hard to type while getting replies.
Basically, the user should be able to configure toast messages; they should not autohide, or the time they hide should be adjustable, or they should be extendable within 20 seconds. TL;DR, self-hiding messages, dialogs, etc are not good for a11y.
That said, the toasts have a button where the user can undo the action taken, which is good for accessibility under criteria 2.5.2 and/or 3.3.4 / 3.3.6
It’s almost like we need a semantic level where the developer says “I want to send the use this small transient text message” and then a presentation level where a user can decide which method of presenting this information works best for them…
Then write mail rules. It's really easy and personally I couldn't survive at work without them. That's a big part of why it's nice: You can choose how it works unlike practically everything else these days.
That ties the app to be usable only with network access (which is fine for, e.g., Youtube, but not for all apps!), and also includes a highly variable lag.
They even acknowledge the limitations and problems with Toasts:
> 1. Add inline feedback
>
> Information in auto-dismissing snackbars must also be communicated using another accessible method inline or near the action that triggered the snackbar.
You will get one toast indicating that it will be deleted, and one a second or two later indicating that it got deleted.
If you delete multiple comments quickly one after another, you'll first get a bunch of toasts indicating that the comment will be deleted, and then, with that second or two delay, each confirmation, but they do get deleted sequentially, so you have to wait for all the confirmation toasts. Which for a deletion of 10 comments will take more than 10 seconds, even if you clicked them all in two or 3 seconds.
Toasts can be bad UX (usually when they are the sole feedback), but they are great in conjunction with other elements.
A confirmation toast with a page-redirection is a great way to add additional indication to the user that their submission was successful.
A warning or error toast in addition to standard form validation indicators gives a great secondary indication to the user that they need to change something.
And if implemented in a catch-all for nonspecified errors, it'll allow the user to preserve the state of their page vs rerouting to an error page.
If used as one tool in the toolbox vs the only tool in the toolbox, it's a great option.
> The "Undo" button in the toast is unnecessary because the user can just click the checkbox again
I disagree with this part, at least in general. Having an Undo is very good if you have accidentally clicked somewhere and don't know precisely where, and you don't know the application well enough to easily undo based on the message alone.
In this specific example you do have an Undo button: the checkbox itself. The issue here is that the checkbox doesn’t match the exact state it’s supposed to represent: if you check it, for a few seconds it’s checked but the video is not yet saved; if you uncheck it it’s not unsaved until the toast appear. If you repeatedly check/uncheck it you don’t know in which state you end up.
> In this specific example you do have an Undo button: the checkbox itself.
That's false. The checkbox itself is not a viable undo button under any circumstances in this specific example (i.e., you accidentally clicked but have no idea where, and let's assume you have no idea of that particular checkbox's state prior to the accident). Any adjacent checkbox would have extremely similar plausibility for a user wondering how to undo.
That said, toast is not great either, because it may disappear before the user fully recovers from their accident (say, a spilled drink). Maybe the undo button (and any async success/error labeling for the original event) ought to be adjacent to the checkbox and persist until the next action taken.
> i.e., you accidentally clicked but have no idea where, and let's assume you have no idea of that particular checkbox's state prior to the accident
That the same for every single checkbox in every single form on the Web.
Even in the unlikely case in which you clicked on the lists button that opens the popin and then accidently clicked on a checkbox without seeing which one and without seeing the checkbox state change, you still have the list of lists on the screen and you can still choose if you do want this video in this list(s) or not.
> That the same for every single checkbox in every single form on the Web.
In my experience, the majority of forms on the web don't commit until you decide to submit, so if you have an accident before then, you can recover (well, buy a sense of certainty at the cost of redoing some work) by reloading the form. In contrast to that majority, here we're talking specifically about forms where each component auto-submits immediately. I think that if a component auto-submits, then anything related to that submission (success/failure status, undo, etc.) should be presented within that very component.
> The issue here is that the checkbox doesn’t match the exact state it’s supposed to represent…
This can all be fixed. E.g. disable the checkbox while it’s processing; or show a small loading indicator; make it impossible to click the checkbox repeatedly. Etc.
A frontend update that doesn’t wait for the server is nice, but only when server state is irrelevant. If the user wants to know about the server state, then the UI should always indicate that.
Yeah, I've encountered that in a few systems: I'm aware I accidentally just changed the wrong thing but I don't know which wrong thing, there are no clues. This is especially problematic when there's a chance nothing changed, but you can't be sure.
To illustrate the problem with "perfect storm" example, suppose a your back is turned and a ball rolls of the shelf and hits the keyboard. Did anything change? What changed? How do you fix it?
This is particularly annoying on Gmail, where sometimes while you type in the search bar, a few of your keypresses will trigger keyboard shortcuts instead.
Did you just archive or delete a couple of unread emails? You may never know!
It's the most annoying thing I felt when I using software too. So in my own project, I tend to just keep the message open and wait for user to decide what do to with it, but then that's not a toast anymore.
I don't think designers should put anything interactive in an arbitrarily timed interface aside from "Dismiss". A toast is the best when it's displaying what is currently going on, not as a pop up dialog box.
The best design for Undo I think is to make it a dedicated button, like the one in the text editors. When user clicked "Archive", a Toast pop up and displays message "Archiving N entries, please wait" and then change it to "N entries archived. You can press Control+C or click [Undo Icon] to undo if that was a mistake" then the Undo button lights up.
Also, IMO the message format "Archiving N entries, please wait" should be a standard, it tells the user in a clear way 1) what the software is doing, and 2) what should I the user do. On the other hand, the message "Conversation archived" don't really provide the same value, since user already saw it happened.
- if your app has a number of messages (eg: “image downloaded” or “message sent” or whatever) then there is a consistency in using toasts as they all appear in the same predictable manner
- often “appear away from focus” is one of the intended goals of a toast; it’s a message that is present, but more in the periphery (the user can ignore in most cases, and it doesn’t obscure main content)
A toast makes sense only in 1 case: when it's a notification that is unrelated with the current action of the user. Similar to OS types of notification that the defunct Growl (memories) invented.
Any feedback from a user action should be done within the context of the user action. If the action is async, it should be clear and the feedback should instantaneously indicate that the action is queued for processing. In that case, the feedback should give 2 options: cancel and access the queue (or better give a vision of its progress ).
I'd add one more scenario: when the UI element that would give feedback, normally, has been removed, yet you still want to show feedback.
If I removed a task from a board, I can't show - on the task - how to undo that action. There's a keyboard shortcut to undo it, but how would the user know, visually?
I'm not going to replace the task with a note because notes don't belong in task lists - only tasks do. I'm not going to come up with some derivative task that only displays a message because then I'm injecting intention that has no function for the task component. I'm not going to just not tell the user because while it is obvious that the task was removed, it's not obvious how to undo what could be an alarming action from a single click (and I'm certainly not going to nag people before deleting a task with a single click; it's a core functionality of task lists. It needs to be able to be done instantly, and undone instantly).
So on and so forth. I'm sure people have tons of one-off, little, anecdotal examples like that. Toasts were invented for a reason. Just because people got cutesy with them doesn't mean they aren't specifically useful for specific scenarios, regardless of how contrived.
Thats one reason for them. The other is for "not important enough to block the user, but important enough to inform them of something". What was previously a popup with an 'ok' button is now a toast. Low friction, medium importance.
A better UX is to show a confirmation in place. When you delete a task from the list - show a module in its place with a short message and the undo button. Showing a toast in a completely different part of the screen is hard to notice and hard to interact with as it's removed after a short delay. Also, if you delete more than 1 task quickly, toasts start stacking, and it becomes even less clear which one you want to undo.
I'm happy to look at your A/B testing and research on the subject, but I'm less interested in your unsupported opinions about what "better" UX is or how unmanageable multiple toasts become.
My case is a reference to a real-life, literal sitaution that I was involved with. The "opinions" expressed as why I would or would not do certain things had PLENTY of A/B testing and research done on them. Not only internally, within my company, but externally out on the open internet. Nothing I said conflicts with extremely common understandings of these UX patterns. And, far more importantly, our internal testing and research backed all of our findings up.
So when someone says "here's a better way to do your UX", they are specifically saying that they have some insight that beats out all of the research and testing I have seen on it. In which case, I am MORE THAN HAPPY to see any of it. I love to learn that certain patterns don't work the way I thought they did! Sometimes it just means they've gone out of style and we need to update with a trend. I'm very interested in making UX the most reasonable I can for the most users. So if I'm doing something wrong, I'd love to see data to support that!
What is less interesting to me is someone saying that their opinion is better without any evidence of that claim. But, hey, I'm open to new ideas: please explain to me what concrete actions I should take based on the reply I got? I should go research it because ne said it, even though it's a very common thing that is said in these discussions and I've never seen it supported? Do you chase down every single lead without asking for the minimum amount of effort to be put in by the propositioner? If this person was earnest about helping me achieve a better UX, rather than just stating their opinion out loud, why is it difficult to follow up with practical data?
Yes, a well tested and well researched opinion. Just like I'm sure your opinion was.
The difference is, I didn't say "Here's a better UX". I said "This is an appropriate use for the UX". I didn't back it up with testing because I wasn't saying anything that needed backing up. I wasn't making a value statement, or insisting on a quality of the UX; I just said that toasts were appropriate for certain functions - not that there was no better way to handle the UX.
You, on the other hand, absolutely did make a value judgement. You said "better". And okay! I'm fine with you having a better UX! I'd love to know more! Please, provide any information you have on why yours is better!
If you need more help deciphering the difference: I was arguing against the blog author's EXCLUSIVE argument ("actually, this is appropriate, so it's not that toasts are NEVER good UX"). You are arguing for your own EXCLUSIVE argument ("the good things about this way aren't available with your way"). If you don't understand why exclusive arguments merit more evidence than arguments for maintaining inclusion (as opposed to changing to be more inclusive), I'd recommend boning up on formal logic.
This is not a formal argument, it's a thread on a discussion forum.
If value judgments trigger you so severely, it could be healthier to log off and read a book instead.
In an informal conversation, it's common to voice an opinion and present an argument. It's also common for other participants to disagree and voice a different opinion.
Informal conversations can actually be wonderul, you should try!
lol
I can't tell if you actually believe that I'm somehow hyper-focused on this because I was able to scrawl out two paragraphs, or if you're just deflecting, but either way it's pretty funny!
I said a thing. You said a thing. I gave you honest and apathetic feedback. You're the one that got defensive about that. You could have left it there; you could have said "oh, I've got nothing formal, I'm just talking about case X, Y, and Z, as brought up in article W."; you could have done anything other than take it hard. Instead you got pissy about me not caring about your unsupported opinion (I make no value judgement on whether it's actually good or bad; just that it's unsupported).
I'm sorry that my immediate response, in informal conversation, is less charitable than you prefer. I don't have any interest in arguing about stuff that has accessible points of well-supported data. I prefer to argue about stuff like art and flavor and preference and anything that doesn't have some reference-able data to make one side or the other impractical to support. If you want to talk movies, or games, or food, I'm happy to volley back and forth about the "better" and "worse" things. But if you want to "argue" that you know of a way for me to do my job "better", I cannot stress this enough: I would LOVE to see your data. Because it will help me do my job better. It's not facetious; it's not smug; it's not a spit in your face. It's an honest offer for you to either provide something that does what you say (at least in your opinion!), or to leave this topic with me. There's nothing tempermental or nuerotically formalized about politely offering a path for the conversation, should it continue. You should try just ignoring the path if you don't want to walk down it.
You got it backwards. There is no way to argue about what music is "better". Or at least no productive way to do that.
When talking about UX, I am expressing an opinion based both on my experience as an engineer and as a user. In this case, I can state that something is better, at least in the sense that it's a more intuitive and an effective pattern.
If judgments like that trigger you - that's ok, I don't have to meet some unexpressed level of data-supported evidence.
> There's nothing tempermental or nuerotically formalized about politely offering a path for the conversation
Re-read your responses and imagine talking to someone in person with this level of nit-picking and animosity.
Another example related to the current action of the user, but outside the scope of the currently-viewed screen: inserting a USB stick, or some other hardware-related function.
There is no context for this, and often an action is required. And even if not, it is certainly useful to confirm with the user that their action was detected.
> If the action is async, it should be clear and the feedback should instantaneously indicate that the action is queued for processing. In that case, the feedback should give 2 options: cancel and access the queue (or better give a vision of its progress ).
Where should that feedback be given for modal operations, acknowledging that 99% of the time when the user initiates the action they want to background the operation and move on to doing other things?
If it's supposed to be a "modal operation", then it's supposed to complete before any of this becomes relevant. When that can't happen (e.g. because of an Internet hiccup), IMO the user should be able to take manual action to "minimize" (reversibly hide) the widget, but it shouldn't disappear until the operation is complete.
> it shouldn't disappear until the operation is complete
Says you, but why? There are many workflows where this would be an unnecessary slow point in the user's work.
It's all about balance. If 99.9% of the time a non-instananeous operation will succeed, and the user has faith that it will succeed, leaving the modal up is a terrible UX. But quietly notifying them on success might not be.
Because otherwise I wouldn't be able to get it back. But if I have some kind of temporary hiding feature, I can easily use that as soon as I notice that the operation hasn't immediately completed. (And again, the common case should be that it completes immediately.)
And if something isn't supposed to be instantaneous, I hold that the interface shouldn't be modal anyway.
> Because otherwise I wouldn't be able to get it back. But if I have some kind of temporary hiding feature, I can easily use that as soon as I notice that the operation hasn't immediately completed.
A toast notification doesn't preclude being able to recover state. Email applications still have an Outbox and Sent folder. A UI that allows you to place orders can still have a Pending Orders list.
> (And again, the common case should be that it completes immediately.)
In the real world, not all operations initiated by the user can complete immediately.
> And if something isn't supposed to be instantaneous, I hold that the interface shouldn't be modal anyway.
Why not? The two things are orthagonal. Collecting information about the user's intent and acting on that intent can often have differing workflow implications and timings.
Blanket rules are almost always useless in UX. Say you have an interface made to place an order. You collect a bunch of details about the order modally. The user confirms and submits the order. But it'll take a minute or two for a vendor to confirm it. What should happen next is COMPLETELY dependent on the context of the application. If this site is where the user is ordering dinner, it makes complete sense to leave the user in a modal state until confirmation occurs, because it's unlikely they're going to be placing another order for dinner immediately after, unless the first order fails. If this site is made for a procurement professional placing 20-30 orders one after another, it makes complete sense to background the confirmation and report status non-modally.
> OS types of notification that the defunct Growl invented.
No. Growl came out in 2004, Windows XP had notifications in 2001. If you consider Clippy's messages notifications, we can go back to at least Microsoft Bob (1995)
It's not like we've had decades and decades of GUI experience where every problem has already been solved. Also, this week's "designer" is smarter than everyone before them -- time to reinvent the wheel!
I would say the article is a bit nit-picky IMO. For every pattern there are probably dozens of poor-use examples. I personally really like the Gmail undo mechanism.
While we're at it let's remove the jargon from other trades, too.
"P-trap" is a confusing word that plumbers use, we should instead have them say "gas barrier". And the word "fuse" makes very little sense in an electrical context—try explaining to someone who's never seen a stick of dynamite why the "overcurrent stopper" is named after a long gunpowder-infused cord! Traffic engineers shouldn't refer to "groups of cars" as "platoons" (they're not in the military!), and software developers should stop talking about "DDOS" and just say "lots of computers hitting my server at once"!
In all seriousness: jargon exists because it's useful to be able to refer to something that you use a lot conscisely and precisely. Your proposed replacements are not concise or precise, and they only solve the non-problem of people not understanding the etymology of the jargon. Part of learning a trade is learning the jargon associated with it, and that's true for every trade.
I get your reasoning but still why use food terms for jargon in UX instead of something else.
Your example of a "P-trap" is good but its not like plumbers are going around saying, get me the "slinky hotdog" to bend a copper pipe, or you need a "banoffee pie" to seal this joint.
Why does it matter to you where the jargon came from? Why are vaguely shape-related jargon and military-derived jargon and acronyms okay but you draw the line at toast?
I would argue that FUBAR, P-trap, Dequeue, HALO are going to have a less likelihood of a context collision than borrowing an existing word that is ubiquitous in society.
For example in Google
"toast"
"toast menu"
"toast ux"
All yield different results
However "p-trap" gets you a narrowed list of results
"Platoon" turns up military answers until I specify traffic. And I'm actually not at all sure what meaning of "HALO" you're referring to—it must be jargon not in my vocabulary, but for me it refers to a thing angels have and to a video game.
Again, it seems like you're inconsistent in applying your frustration with jargon. You're frustrated with jargon in an adjacent profession to yours, but don't seem to apply the same logic to professions that are entirely unrelated or to your own jargon.
I’ve been a developer (primarily back end) and I never heard the term toast until now. Perhaps I’m just simple, or maybe I stopped paying attention after “hamburger menu.” I’m probably too old to hang out with the cool kids anymore.
As a developer who started with jQuery and then Backbone.js it seems like frontend dev has become very rich but at the same time has developed some weird esoteric rituals and practices which don't seem to go with conventional software engineering.
I'm curious as to how you're defining 'conventional software engineering' here; can you give some examples of things that are not conventional software engineering in the front end?
Front end is more specific than conventional – it has a graphical output, and is thus closer to 2D game development than to the “conventional” data structures and algorithms way of programming.
Rather than trying to solve that communication problem, why not just label the menu with an actually descriptive icon? I assume that this icon is supposed to convey "there is a menu under here", via the horizontal bars abstractly representing menu items. But to me that's a vastly less clear visual language than even MacOS 6 offered me in the 80s, even limited to 16x16 black-and-white icons.
Menus are supposed to have titles so that you know what's in them, not just that there is something in them. It's especially obnoxious to see a hamburger menu next to other icons that happen to be for other menus. First off, this fails to convey that they even are menus, and not, say, buttons. But it's especially obnoxious trying to guess what menu items the hamburger menu might contain. Even if you decipher the other icons, you're left with speculating about all conceivable menu items, and then applying process of elimination.
Hold on, how is "hero" a food metaphor? I mean, I understand that there are some regional dialects that use that name for a "submarine" sandwich (and there are many other names for it), but I can't fathom how a full-screen image at the top of a website has any metaphorical connection to that. To me, that makes even less sense than the idea that such an image somehow is supposed to do a heroic job of advocating for whatever is the main point of the page (unironically my prior mental model!).
It's not a food metaphor, nor is it about displaying something heroic, although that's much closer. "Hero image" comes from "hero props" which "are the more detailed pieces intended for close inspection by the camera or audience. ... The name refers to their typical use by main characters in a production." [0]
Since the name arises from use by a hero, then to extend the metaphor by direct analogy, the actual hero is the overall article/content in which a hero image is contained.
That said, a "hero sandwich" is that which "one needed to be a hero to finish" [1] so does all tie back to the idea of heroism regardless.
I tend to agree but I think toasts can still be useful and good UX. Putting useful and actionable feedback in context instead of toasts is a rule of thumb that I try to follow but it's not always appropriate.
For undo-able actions, toasts disappearing too fast or colliding with other toasts badly is a real problem. An affordance to see the toast history with non-disappearing undo buttons may be more to implement but for a lot of apps, a viewable and editable history combined with toasts is a much better UX than either system on its own.
I'm not convinced. Most of the argument seems to be that redundant UX is bad UX:
> But by archiving the email, the email disappears from the list, which already implies the action was successful.
> In this example, the button already includes a confirmation so the toast is entirely unnecessary.
I vehemently disagree with the idea that just because you're already communicating something one way it's bad UX to include another way of communicating the same thing at the same time. Redundancy in communication is a feature, not a bug, and it's present in all human languages. It ensures that even in less than ideal conditions the message still gets through.
In the case of toasts, having a single, standardized way of communicating the status of all actions (and if possible providing the undo) allows a user to quickly pick up on the pattern. Extra indicators closer to the action can be valuable too, but it's when they're paired with the toast that their meaning becomes entirely clear. To remove the toast in favor of a bunch of specific indicators is to force your user to learn several different ways of saying "it's done now" entirely from context (many of which will be small and subtle as in the examples given). This might work fine for you and me but isn't great for, say, the elderly or the vision impaired or children.
Unless they're actually getting in the way, toasts aren't bad UX, they're redundant UX, and a UX designer shouldn't be striving to optimize away redundancy.
I agree. In the first example, you would assume the action completed even if you missed the toast. But in case you did notice it, that gives you a confirmation. Suboptimal? Maybe.
But the proposed solution is clearly worse, unless the loading circle turns into a tick to show completion
The unfortunate thing is they aren’t communicating the same thing.
Taking the YouTube example, the checkboxes are 100% optimistic while the toast notification indicates that the request to the backend that was fired off asynchronously was successful. With the archive message example, it is the same thing. The message is removed from the list optimistically and the toast message is representing that the message was actually archived.
I would much rather only get the toast if there is a failure to commit the change. Generally, them flashing up is a distraction from what I’m trying to accomplish. And being far on the screen from where I’m taking an action makes them even more of a distraction.
I disagree on that—in the YouTube example specifically this isn't necessarily a problem, but the toast serves a valuable purpose in the archive in that it tells you again which button it was that you pressed. There have been countless times in cases like that where the toast has saved me and allowed me to undo a misclick.
I can see the argument that there are certain places where people use toasts that are unnecessary and provide information that the user doesn't need. But that's not the same thing as toasts being bad UX in the general case.
Toasts also give you a good place to put other shortcuts like “Item updated. [View item]” that make it much easier to act on state changes, like navigate to sensible places to view / react to those changes.
Screen reader's probably not going to catch a transient element unless you just happen to stumble across it within that narrow window. Slow reader for whatever reason? Hope you don't take too long, or hope that toast wasn't actually important/actionable for you.
> Toasts also give you a good place to put other shortcuts like “Item updated. [View item]” that make it much easier to act on state changes
Not if they go away, and take their “[View item]” button with them, before you've had time to read the notification, decide if you want to click the button, and actually get your cursor there to click it.
Which they usually do. So nyaaah, dubious benefit.
If something is so hard to implement that everyone who tries gets it wrong (to a first approximation), then maybe the concept is bad. Or, at least, the concept isn't fully baked and is missing something critical.
Most implementations of toasts-with-actions that I've seen don't have the problem OP described. I more often find myself manually dismissing them than wishing they'd have stuck around longer.
Should complex websites have a notification center where you can look at prior notifications? Would this be alike enough to existing desktop metaphors to be easily recognizable or simply confusing.
Maybe your browser should could have an icon for same instead making it more standardized across different sites.
> Browsers that support JavaScript typically implement the Notification API. This API asks for user confirmation to allow popups and give the programmer the opportunity to display notifications with a text (body) along with an descriptive icon and header.
Indeed. I would rather all browsers just disable it by default with not even the popup asking if I want it. If I install a webapp as a PWA then maybe ask me. Otherwise? Website operators are on crack if they think I want them to be able to spam my desktop multiple times a day even months or years after I visited them!
Yep, if this feature was limited to the window in focus, then the API could make sense. The way it is now, I know all savvy users will just block it, and many of the non savvy ones will too... Complete waste of time to dedicate developer resources too over e.g. in-line toasts.
Sure! Unfortunately I am not sure I’ve ever seen the api used for anything other than what I’d call spam. To the point where as soon as I’m prompted I’m finding that “block” button before even speculating what it’s supposedly for.
I only allow notifications from a tiny number of sites. The ability to notify me while on the page is different from notifying me while the tab is in the background and more so yet than the ability to bug me whenever.
Ask for everything get nothing. I imagine most people click no
I'd go for an action log. It's almost the same thing, but notifications imply ephemeral pokes about some of the stuff that happened, mixed with engagement boosting spam - there's a lot of unpredictability embedded in this concept, as the app is usually trying to guess what you may (or it thinks you should) find relevant.
An action/activity log is just a reverse-chonological log of things that happened. You could make one by recording every would-be toast and putting it on that list, complete with a timestamp, and any of the context-relevant action buttons (like "undo", or "view item", etc.). The list should be a fixed recording[0], without any way to dismiss some or all of the entries. Add some attention-grabbing indicator whenever something is added there, and you get all the benefits of toasts with none of the drawbacks: the log lets you report completion of optimistically-executed actions, provide place for context-relevant buttons, and also is accessible, can be browsed at uses' own time, improves discoverability and learning, and can be upgraded to also enable undo feature.
--
[0] - Well, appended from top, and possibly unwinded by undo. Users understand that. Can't be append-only, because mixing that with undo gives you the undo system from Emacs - very powerful but also nearly incomprehensible to most people.
I love this idea! And also I like how it implies dispensing with the wrong notion that I care about every so-called notification and thus that I have “unread” notifs.
I think the best UX for async actions with optimistic UI updates would be having an (attention-grabbing?) indicator when an action is added and then another when it completes as well as indicating the number of pending (i.e. unconfirmed) actions and a persistent indicator if any of the actions failed.
Fair enough, but when they are not communicating the same thing, there are no grounds for objecting to them on the basis of redundancy.
The problem with notification only of failure is that one is left uncertain about success, though I would agree that striking a balance between distraction and uncertainty is difficult.
It also would mean you would move the item eagerly, then put it back on error. Or alternatively make it a "ghost" item in the list then remove on success. But overall the eager-move + toast + undo is just a much faster feeling implementation and the overall UX is so much cleaner.
The undo button justifies the toast here IMO. Otherwise I'd prefer ghosting really.
For the checkboxes, I'd say GitHub nailed it: for settings that are applied instantly (e. g. https://github.com/settings/appearance), they show a spinner and then a single checkmark right across the section title. (It used to be next to the input element – both ways are fine, I think)
I agree they do a good job, but I think a toast without undo could also work there. Apply the UI eagerly, toast success or failure. As it is, I assume on failure it becomes an 'X' and shows an error? I just dont generally like very short transitions like the spinner is currently. In general, coming from app land, I prefer a deferred loading spinner that only shows if the action takes X ms. So in the happy path of a fast action the user never sees the loading state.
That's the problem of whether the developer and the user have the same expectation of the max duration or timeout of an action. For example a developer might default all backend actions to have a timeout of 30 seconds. But as a user, if the action succeeds quickly (the usual case) I want to immediately see a confirmation of that. I don't want to wait 30 seconds just to see no notification about any failure.
I mentioned this in another comment, but the whole reason the archive is able to be optimistic is partially because they offer the undo via toast. Otherwise its likely they would add an 'are you sure' plus a loading-state when doing these "semi-destructive" actions.
You can offer Undo via things other than toasts, though. In fact, I wish more software offered Undo--the Undo feature has kind of gone out of fashion since the early 2000s. You should be able to Undo anything (and follow the Undo chain back through many past actions). We somehow lost this ability from software.
Undo's (and especially re-do) are quite hard and resource intensive to code, especially for web apps that can be simultaneously accessed via multiple devices.
E.g. you can take action A on your laptop, followed by action B on your phone. Undoing action A may not be easily possible if it was followed by action B.
To make that work properly you need to activel sync states between all the users devices using e.g. websocket or what-have-you. Handling edge cases becomes quite the nightmare, e.g. phone has poor connectivity.
Only the big guys would have budget to do these sort of things (And make them work well).
I've accidently archived something only to realize it when the toast pops up. I'm grateful for the toast instead of having the 'are you sure' like you mentioned. It's a nice compromise.
Theres an implicit assumption that the actions being offered an “undo” are semi-important/permanent.
In other words, if you delete an email and it goes to the trash folder: good use of toast + undo
If you empty the trash, and there is nowhere the user can go to unempty it: bad use of toast + undo
Its also useful as a sleight of hand eg when cancelling an action you havent yet taken (which actually is generally what a toast + undo actually is). The best example of this being toast + undo for an email send
Toasts showing up far from where the action is take also makes them super annoying for people (like me) who use screen magnifiers. I'm oftne using a site while zoomed in, and will completely miss a toast, because it never enters the "viewport" on the screen I'm looking at.
What kind of design choices do you find helpful with using a magnifier like that? It's not something I'd ever considered before, sounds tricky to design for but I'll try to keep it in mind now.
- Put cause and effect close to eachother
- Don't block my view based on mouse position. I hate video players that ofverlay the pause button when the mouse is over the video, or images that get obscured by some overlay when hovered. My zoom follows the mouse, so I can't move what I'm looking at and where my mouse is pointing independently.
Oh yeah those video players are awful for anyone on mobile too, always ends up somehow getting stuck active and the only way to dismiss it is tap the video, which of course is usually bound to some other disruptive action like pausing or exiting full-screen mode.
Adding to your examples, I hate when video players (both mobile or desktop) don't let me hide the video player controls when the player is paused! I also dislike having to wait a few seconds upon starting/resuming a video for the controls to fade away.
> I hate when video players (both mobile or desktop) don't let me hide the video player controls when the player is paused!
Agreed. This is exceptionally annoying! Who thought this was a good idea? Why don't people copy proven video interface behavior from Google. Why go out of your way to annoy your users?
> I also dislike having to wait a few seconds upon starting/resuming a video for the controls to fade away.
I get the annoyance, but especially on mobile, it conversely helps if you want to advance the video by as few frames as possible to catch a freeze-frame gag or something like that. If the UI immediately disappeared upon resume, you'd have to triple tap to immediately pause the video again. (On desktop you can just mash the keyboard or even use a dedicated "advance one frame" key, but on mobile that's not available.)
I sometimes use a Bluetooth speaker on mobile just so I have a pause button handy. Playing a video full screen requires me to tap once to bring up the controls, and then again to pause.
> I hate video players that overlay the pause button when the mouse is over the video, or images that get obscured by some overlay when hovered.
This shit is super annoying for everyone. Even people who do not use magnifiers. Who decided that this was a thing to do and why? I would like this pattern to meet sudden death.
Good questions - also note that fixes that would help magnifier people also benefit users who have overlapping windows and/or windows partially off-screen. (This is also an example of accessibility features helping people who are "fully-abled")
> I would much rather only get the toast if there is a failure to commit the change ... And being far on the screen from where I’m taking an action makes them even more of a distraction.
But wouldn't this situation be even worse with a failure-only toast? A request timeout could happen 30 seconds after the fact. You're likely in a very different UI state at that point, and unless the error message is very specific, you'll have no idea what even failed if you are quickly performing lots of actions.
I agree. If it's available, I always appreciate a toast + notification tray combo where you get non-blocking feedback on successes but you can also keep track of any past messages.
I don't entirely hate toasts, I don't think your example is good, either. A toast is best for asynchronous, high priority, fleeting information.
You don't want to stack them, or if you do you need some sort of inbox for them. You don't want to be spammed by them, you don't want them used as a stand-in for representing object state.
For a checkbox, I'd rather the info be communicated "inline" maybe by color/shape/shading. A toast could be used like an info popup, perhaps i.e. "why did my checkbox get reverted".
Or it could be for a high priority event, that just doesn't fit (well) in the current screen. But, again, care should be taken.
If you communicate with your user, don't spam them - provide them with prompts and visually appealing methods to obtain their data. Toasts can be a part of that but shouldn't be the first tool reached for (ideally). I think the reason they are so dangerous is because they are outside the main UI flow, its technically and visually "easy" to use them.
A grade A implementation would keep a local state that syncs to the server, indicates a sync is in progress, possibly stacks changes to reduce latency if there are a lot of changes + a slow connection and, to a user, gives me utmost confidence that I’m not going to lose data.
Now my presence is to use this grade A type of implementation because I like very solid software and I’ve done it so many times now that I can bang it out in a coding interview. Or explain it to a team so they can implement it.
But your average app is like a grade D. Even Instagram or Snapchat where I’m never too sure if my stories are going to be in order if my connection fails or even though it lets me cancel an upload, if I do it slightly too late the app fails to cancel because it can’t keep track of its own state through a state transition.
So for 99% of apps, I want them to put a redundant toast. I do not believe they can build solid software with proper state management. At least the redundant toast lets me know it did go through. A lack of toast doesn’t mean it went through because some people barely can implement error handling.
Even with your description of a gradee A webapp that uses local state management effectively + shows syncing + queues with stacking + connectivity detection and exponential retries etc. I still feel like toasts can be useful to indicate to the user when are not in the "normal" state. I feel like especially mobile apps fail horribly at this, it is very normal to walk around a city and end up in dead spots. Having a clear indication from the device that we are longer in Kansas can be very useful. IMO toasts that plop up for successfull actions are often quite useless and redundant.
> I would much rather only get the toast if there is a failure to commit the change.
I would much rather the sequence of commands issued through the ui be a declarative state change queued until committed without bugging me about an error I can’t directly fix. Toast that backend chaos monkey, not me.
I use a computer mainly by using a zoom tool to magnify the area around my text and mouse/finger cursoe. I miss almosst all toasts and most notifications because they not where I’m working. For my use case, feed near the item I’m interacting with is the only valuable feedback.
I assume you don't want a full screen reader if you're not already using one, but if toasts are properly implemented (big if), screen readers can actually present them accessibly via the ARIA alert pattern[0].
Wanted to mention in case you're not aware and maybe there's some tool somewhere (or some way to configure a screen reader?) so that you can keep your simple zoom workflow but still benefit from the ARIA alert pattern.
Thanks for this! I visited your link and hadn’t seen such a nice demo with working code on w3.org before: whoever worked on these pages deserves kudos.
None of that invalidates what your parent comment is saying. They’re not saying you should use toasts to the detriment of other options, but in addition to them. If anything, your comment reinforces the notion that redundant information is beneficial because you don’t know where the user is looking.
Yes. For example: while OP uses a magnifier, lots of other people use a screen reader. "Loading indicator disappeared" is a tricky thing to communicate clearly with audio. "Toast: save successful" is trivial.
This is something that I think a lot of people miss. There is for sure a reason why google has that toast. One shouldn't just dismiss what the big tech guys do in terms of UI because they are among those who have the most resource to spend on it, and also the most amount of users. So for them it makes a lot of sense to spend effort to cater to people with various disabilities, as there is financial profit in there for them.
For a small regional golf court chain who want to build an online tool for reserving tee times? They most definitely won't have the budget to do things entirely properly.
I was attempting to suggest toasts "are bad UX", but your points make a lot of sense. Thanks.
There was some discussion in the article and elsewhere in the thread about how a toast with an undo button could be a very useful interface pattern. It wouldn't work for me, so I would hope that UX designers that want to use toasts would also design in other means to find and execute an undo action.
For you, my comments reinforce that toasts are "good UX" when they contain redundant information. I'm warming to the idea. In parallel, for me, this discussion is reinforcing my intuition that "actions and feedback as close as possible to the area of interaction" should be considered the primary vector.
Same here, in the last 2 years, my eyesight has gone down a lot (combination of astigmatism and presbyopia is not great). I used to love the growl style notifications from macos, now I always miss them (and often miss the alert that I only have 5% battery left).
The issue with the not seeing toast notifications is that in some apps it’s the only true notification that the request went through to the server so missing them when they failed for whatever reason is rather annoying
I think this is because a global toast service is trivial to implement, one service class / event listener, one UI component. It takes one ticket to make, and then it's just a matter of implementing the event publishes // serviceclass calls. This is much faster than implementing a plurality of ways to indicate loading and resulting success/fail.
In other words, it's a crutch that is often taken when there isn't enough budget/resources to make a proper UI (Or enough care/love/interest/skill).
I have definitely myself gone down the quick path of implementing only server side validation + toast service for projects where the customer just does not have the budget to do things entirely properly.
I think the suggested improvement clarifies what he means: if you're worried that the UI element the user is interacting with doesn't fully convey what's happening, then improve that element rather than adding a second element that divides the user's attention and challenges them to read quickly and make the connection themselves. Communicate the failure of their interaction in the context of the element they interacted with, so the connection is clear.
A toast makes sense as a worst-case, last-gasp, no-context attempt to communicate with a user. In this example, if the user unchecked a playlist and dismissed the list of playlists while the save was happening, and then the save failed, a toast makes sense because the context of the action is gone. Might as well put the information at a random spot on the screen.
Even then, a toast probably isn't the best you can do, if you really want the user to understand the error. In a the-user-is-the-product adware application like YouTube, you probably don't care if the user misses errors like these (and might even prefer that they do), but in a business application you wouldn't want to gamble on the user missing the toast or confusing it with a different error. It might be more helpful for a normal user if you re-open the element and show them the error in context. Open up the list of playlists and animate something to draw their attention to the fact that their change didn't save. I'm probably getting pie in the sky here, because that sounds really difficult to do in a systematic way, but in an ideal world, you'd always see errors in context.
I get what they were saying and agree that in-context feedback should be added wherever possible. I just disagree that leaving off the toast is (in the cases cited) valuable.
Taking the archive example: yes, the disappearing message successfully indicates that something happened. But it doesn't tell you if the message was deleted or archived, and misclicks are common. The toast unambiguously communicates what happened in addition to saying that something happened.
Additionally, I stand by my argument that consistency is valuable. By all means have in-context feedback, but also pick a standard way that you always use to communicate completion of all actions. It makes it a lot easier to understand and eventually make use of the in-context feedback which may not be as intuitive as you think it is.
> I just disagree that leaving off the toast is (in the cases cited) valuable.
But adding a toast isn't free. It's a distraction, and arguably a pretty intense one for ND folks -- especially when it becomes a standardized message center with multiple items queued up.
In many cases the most useful toasts would also be better if they weren't toasts. For me, the most useful toast I interact with also demonstrates why toasts are bad UX: creating a new ticket in Jira. Since that can't happen instantly, it needs a delayed message to let you know when the ticket is created and you actually have a URL to open. A toast is useful in this case, but it's also far from optimal, because for some reason it's going to disappear in a few seconds, and it also won't tell me how many seconds I have left to read it.
Why would distraction be the primary mechanism? We figured out decades ago how to put a button in the header that opens a messages feed which the user can read and dismiss at will. While it's possible to implement such a feed badly so that it's annoying, it's difficult to implement toasts in a way that aren't annoying. Maybe even impossible.
> But adding a toast isn't free. It's a distraction, and arguably a pretty intense one for ND folks -- especially when it becomes a standardized message center with multiple items queued up.
Diagnosed with ADHD, so I'm guessing an ND folk here: modern applications in general, and webshit in particular, give me huge anxiety because of all the eventual consistency and optimistic actions bullshit[0], coupled with flakiness and bloat of entire modern software stacks[1]. Maybe "toasts" aren't the bee's knees, but they work as lagging indicator that something happened that I otherwise wouldn't notice, and in some apps even lets me undo the unwanted operation. That does a lot to relieve my anxiety and help me use software with less frustration.
--
[0] - That itself is a big antipattern. Software lying to user about its state is a form of gaslighting; it makes interaction more error-prone, and prevents users from building correct mental models of the application and its interactions with other systems.
[1] - My Android flagship lags often enough on taps and drags that every other day my input gets misinterpreted and does something unwanted. Similarly, I type faster than most software - webshit in particular - can react, so e.g. a small jitter can turn "ctrl+t n e w s <ret>" into "ctrl" (held, released) and then "n e w s <ret>", which does $deity knows what in the current tab.
> Maybe "toasts" aren't the bee's knees, but they work as lagging indicator that something happened that I otherwise wouldn't notice, and in some apps even lets me undo the unwanted operation. That does a lot to relieve my anxiety and help me use software with less frustration.
All things that a message log does better than toasts!
Why not both? A message log can always be consulted later, but it doesn't give you a live feed of things that are happening.
I'm also ADHD and, like OP, I appreciate having the stream of toasts that lets me know what the software did. It's saved my butt a bunch of times when I accidentally do something I didn't mean to (deleting instead of archiving, for example). A message log would just get ignored, but toasts help a ton because they're visible.
A message log can also be visible...? The only differences between messages in toasts vs messages in a log is that toasts control the user rather than the other way around.
Isn't a toast just the tail of a message log that's visible for a few seconds after a new message is added? I don't always want the entire log to be occupying space on my screen, but I do want to see when new items get added.
Exactly - a toast is, at best, a nice add-on to a message log. Although I maintain a well implemented message log already serves every single purpose toasts do, better.
I don't even know if I'm neurodivergent, but apps that optimistically indicate success instead of using spinners give me a ton of anxiety. I see that in my wife and other family members, too. Even looking at something that explicitly says "Your order has been placed!" leaves people in a state of nervous suspense until we find a text message or an email to verify. In the absence of that, they just don't know. Part of my techie privilege is that I know a page refresh can usually reveal the truth.
> Even looking at something that explicitly says "Your order has been placed!" leaves people in a state of nervous suspense until we find a text message or an email to verify.
This. Also true for both my wife and me. One of the worst offenders here are contact forms - it's increasingly rare you get any copy or confirmation via e-mail that your message was actually recorded, so once you submit the form and see a success page, you really can't be sure if your message was delivered, or even if it left your browser in the first place. Takes one little JavaScript fuckup for the message to be lost, and your only indication may be an error message in development console.
Related, at one of my previous employer's, there were some documents I was interested in that had restricted access; when trying to open them, I'd get an access request form asking me to provide a reason. I filled it several times over couple of months, but never got any reply. Then one day, I mentioned it randomly to my boss, to which he told me that this form just goes straight to /dev/null...
Yes. And I've never once run into issues with redundancy of information being a problem. It's the clever things people do to hide information or to be concise that reliably get them confused.
> The closer you can get to the whole UI being a single sentence and two buttons the better.
Sure, but this is kind of my point—clever UX tricks to communicate things without words don't work for them. A toast is valuable for the tech-illiterate precisely because it uses English text to communicate its point, and having it exist in the same spot for every action makes it easier for them to pick up.
It's not the be-all end-all of UX design for the elderly, but it's a heck of a lot better than the alternatives proposed in TFA.
Things disappearing with insufficient explicit feedback for what actually happened to the things is one of the most common issues I've encountered with older computer users. I think it's the most common issue. Toasts add persistency and visibility for users who barely or don't understand the UIs they're interacting with, which makes it easier to understand what happened.
If Outlook gave feedback to every user action in a toast, then provided a universal history of every toast, you would probably resolve a significant amount of issues caused by user actions leading to unintended changes (and being unable to recognize that the action lead to a particular change, or even how the current state differs from the previous one).
The whole point is that they DON'T add visbility, because they're not presented where the user is working. Age isn't even a factor.
It's time to stop blaming "age" when the more likely explanation is EXPERIENCE. Many people learned to use computers in an age of well-understood GUIs that hewed to standards that evolved for very good reasons. For example, buttons that were depicted (in a clean, not cheesy "skeuomorphic") manner. You can tell at a glance if a well-depicted button is on, off, or disabled.
Then enter the idiotic "flat" design fad, where the entire screen was an Advent calendar of no controls at all... or is it ALL controls? Click on every piece of text and every rectangle to look for the hidden goodies.
Those conversant in (and tolerant of) more-recent UI have simply become accustomed to shitty UI. They've either forgotten how bad it is, or grew up not having experienced good design. Another great example that has disappeared in many areas is GREYING STUFF OUT. If something is not currently usable because it's not applicable, you don't just make it disappear. You grey it out, so users can learn
1. That the function exists
2. Where the function resides
3. What conditions must be satisfied to make it work
This discussion tells me we have not yet reached perfection in UI! Toasts are good for me, but definitely not good for the users you and others have described.
My hope is that small AIs inside UX can help here. Can you tell your UI framework something like, "Give them a choice between X and Y." and then "Clearly indicate they have chosen Y." (with a fallback of "Tell them something went wrong, and they won't be able to make a choice right now after all.")
Or is it simpler than that, and we don't micro-manage the AI-powered UI engine? "Get answers to these questions, and submit them to this API." — and UI engine does all the rest? I'm not sure.
Anyway, an improved UI would adapt to the user — think of the way a person providing a service adapts to the customer, intelligently and empathetically. For example a teacher watching for signs of understanding in a student, adjusting explanations. A car salesperson being quick and businesslike with one customer and listening patiently to another.
The given examples seem pretty poor. An email disappearing from a list doesn’t tell me it was archived. Maybe it was deleted, maybe I accidentally hit some button and I’m not sure what happened.
Honestly I think the perennial "Java is too verbose" complaints are completely overblown, and say more bad about the person complaining than the language.
In general, I think the best use of toasts are to present options for further action (if needed).
Take the example of deleting an email and getting a toast that lets you undo. Your action has already been completed and you can see it. But you have more context that can be acted on. In this case it's not redundant, even though it relays the action you just take.
In this scenario, it's ideal to move this away from the viewport the user was in. In most cases, they don't need it. But if they do, it's onscreen.
Simple confirmations that do nothing else are redundant. But toasts don't have to be used that way.
No, they're bad. Messages that are on the periphery of my vision/attention (imagine a widescreen monitor) are actively confusing. I'm working on THIS problem here and something flashes up over there. Half the time, as I refocus to read this annoying intrusion, it disappears.
It's bad UX. Put your damned messages where my attention has already been directed to BY YOUR UI.
Yes! The problem isn't duplication of the message, nor is it that they convey slightly different things. The main problem is their lack of locality.
We can have an indicator, then some icon or even a green bar in the "save this" modal, just fine. Or we can make the "archive" icon color different, or add an error, an undo-button, or other message next to it if we really need to convey this information. This could be a tooltip, something in the icon-bar, or anything really: as long as it right at the place where I made the change and expected the change to show up.
The inevitable tradeoff here is having a somewhat standardized location for notifications versus allowing them to appear arbitrarily determined by the developer’s notion of where they are ostensibly drawing your attention. Maybe that’s worthwhile, but I think there are going to be a lot of cases where the ideal location is ambiguous, or where devs have an idea for where your attention will be that’s not always correct, or where bad actors exploit this flexibility to make it look like something it isn’t in an effort to trick users. I don’t know the right answer to what might be best, but I tend to think that standardized features should be preferred when in doubt.
It's not standardized. And putting notifications on or right next to a control you're INTERACTING WITH is not "arbitrary" at all; you must be looking at it, because you're using it.
Doesn't it depend on your platform, and isn't experimentation the way things become standardized?
User notifications on MacOS are definitely standardized, but originally they were Growl notifications until Apple made it a first-party API and iterated on it.
Some conventions transcend platforms. The aforementioned greying-out, for example. And sure, we have to try something for it to become a standard. But in the end the standards percolate up because they're intuitive. The controversy over some of these "toasts" shows that they don't meet that bar.
And you are right in that the Growl-style notifications in Mac OS are standard now... but those are different from the ones in question here because they are not related to a control that the user was just manipulating. They could come from anywhere at any time, and thus they must be presented in a location independent of whatever the user is doing.
The Growl-style notifications work well because they're near the top of the screen, too. Users are used to status and information in menu bars and so forth, in accordance with the general top-down convention of presenting information.
Thinking it through, I did actually implement a "toast"-style alert for asynchronous issues in one application. It was at the top of the screen, though. I originally put it in there strictly for debugging, but I think I might have left it in the release. So I'm not entirely opposed to the idea, but mainly its placement in the examples discussed here.
Depends on gap between the interaction and notification. If the person has already moved on from the page, then next to control is not possible. In which case notifications at some standard position makes more sense.
What if another thing errors at the same time? If you put the error just where you clicked it, you may well miss it. If all things like that happen in the same place (e.g. bottom right) then you won't.
It's pointless pretending there's one perfect guiding philosophy and all others are obviously wrong.
In some cases, the current user's focus is unrelated to the notification. For example: if the notification is alerting you to some foreign event like an incoming message, an app reading the clipboard on its own, an alarm, etc. -- some kind of standard positioning is needed for this.
I believe toasts should be confined to this scenario I'm describing, and indeed feedback directly coupled to user focus/input should be located near to that as you say.
> Put your damned messages where my attention has already been directed to BY YOUR UI.
Ok, so where does the toast go if you've already scrolled or otherwise navigated to a different area of the UI? These optimistic updated could take multiple seconds to succeed, and maybe as much as 30 seconds to fail.
If the "toast" can persist through that behavior, so can feedback positioned more sensibly. How does putting something on the other side of the (potentially huge) screen solve that "better?"
Not to mention that, if the operation fails, isn't it likely that the user will want to re-try? And that'll require access to the original control in all likelihood.
If the user scrolls away and the information is important, use a modal alert.
If you can't show me a spinner or other indicator that this is an ongoing operation (which I find preferable), and you think I will have moved away from the controls for this, then put it in a central location that I will see even if I am still on your control, not in a little box on the other side of the screen.
These toast notifications just are a bad solution. I often miss them, because I'm, you know, doing work, not scanning my monitors for notifications I mostly don't care about. (Redundancy is not harmless. Redundancy also trains me that your messaging is mostly noise.)
> > But by archiving the email, the email disappears from the list, which already implies the action was successful.
Yeah this in particular bothers me. Someone that knows UI and UX should also know you can absolutely remove something on the front-end without a corresponding action on the back-end. If I click archive and the email disappears, that doesn't mean the back-end call succeeded or has even been made. How many times do you click move/delete/whatever in an app, the thing moves or disappears then a second later pops right back in? These things happen and the subsequent alert that it was actually successful is a good thing in my opinion.
I didn't miss that point, I'm arguing that that point doesn't prove anything about the merits of a toast.
Their examples are all arguments of where local information should have been displayed. I agree with them in general. I just think that a toast should also be displayed in each of the situations they identify.
What seems to have happened is that they correctly identified a problem with lack of local information and blamed it on the presence of non-local information, which is fallacious. You can have both, and I believe that a UI with both is generally more usable.
As someone with a human-computer interaction degree, this thread deeply saddens me. In general, human-computer interaction is considered a field of computer science, which I guess hn has a good representatin of.
And yet the discussion here seems to veer off from actual verification of whether toasts actually work, and all the discussion seems to be purely speculation. Granted, there is general argumentation too that's valid to some degree, and it's good to present that, and at the end of the day the only actual data that can guide this decision for a given user interface comes from user testing that is highly context sensitive.
Why? Because there exists no general answer to this question at all. It depends deeply on who your users are, and before the industry understands this basic fact that we as a species are mostly incapable of predicting what different persons from a different user group point of view will be, usability testing will be critically needed, and until we actually start doing it, we will keep creating user interfaces that marginalize everybody but ourselves.
With SPAs, stuff happening in your browser doesn't imply any action has been taken on the server. Gmail lets you delete without an internet connection. If it never reconnects before the page is abandoned your changes won't be committed. A toast that is only triggered by a server acknowledgement has value.
You apparently missed the bit where redundancy in communication is a feature, not a bug. "It ensures that even in less than ideal conditions the message still gets through."
Sorry I have no idea what he's even talking about after the first couple of paragraphs and screenshots, so while I'm very interested in good UX, I'm left thinking this author is not an expert practitioner.
They are bad UX if I can't disable them. I universally hate all notifications. Stop stealing my attention. It's cognitive abuse bordering on violence. If I want to know I will go look, you don't need to shove it in my face.
400 comments
[ 2.3 ms ] story [ 458 ms ] threadThe post shares a few real-world examples and illustrates some of the problems with how they use toasts.
What do you think? Are toasts overused? In which cases do you use them in your own apps?
90% sure it's called this because toast is what pops up out of a toaster.
https://dribbble.com/shots/3072186-Pop-up-toaster-motion-des...
ETA: If they actually behaved like that, it would help with OP's issue with them-- pop out of "the toaster", where you clicked to initate the action, so you'd be more likely to notice. Seems his complaint was in large part that they appear somewhere else. (So they're not really "toasts": At least my toaster doesn't have a teleportation function, to make the toast appear wherever the toaster designer has more or less randomly decideded it should. It just pops up the bread in the same old boring position where I know to look for it.)
I think so, yes.
> In which cases do you use them in your own apps?
I don't. But I don't write mobile apps (where they make more sense) for distribution, so they don't address any need my applications have.
But there is nothing wrong with a toast in a pro app. The pro user will get used to where feedback comes from on the screen and find it is second nature to notice the toast.
In practice, there are very few UX principles that generalize across every interface.
This is 10x more subtle than any toast.
Do you wish that were different? Or does that work for you?
As seen in the article, do we need a notification following a click to every checkbox? In most cases, the user should assume that the action is completed the moment it's taken. If not, you can add an inline loader and show a regular, maybe modal error if it happens.
"Save" actions, with the exceptions of large data, does not need further UI. Particularly the circle should be seen as a marker of the current state, not as a way to tell whether your action has completed successfully, so you shouldn't view it as a "10x more subtle notification"
I spend all day in “pro apps”. I am also visually impaired. The inappropriateness of toasts has nothing to do with my familiarity with the app. I may, eventually, learn that a particular UI is using toasts to indicate something. That doesn’t suddenly make it okay. They’re still a massive pain in the ass for me. They’re still a massive pain in the ass for a lot of people. They’re still a poorly thought out holdover from the days of 640x480 displays, and with a modern resolution they’re even less appropriate.
To respond to your point,
(1) is it a PITA because it’s hard to see something in the periphery or for some other reason? (2) Is there an example of a web app that you’ve noticed provides feedback very well? (3) would you consider a toast acceptable when the UX designer doesn’t consider the information critical? As in…the user can safely assume their action was accomplished but a little feedback is a nice sugar.
No, pro apps actually have completely different UX requirements.
In a pro app, the UX requirement is to be able to perform actions QUICKLY and RELIABLY, meaning it works the same way every time with a minimal number of steps.
This leads to "cluttered" interfaces with lots of information, because this way actions can be performed quickly AND results/data are always in the same place so it's reliable. Take an IDE with multiple panels with output going in/out. Quick to see what you need to, everything is sectioned off so you know right where to look, and everything is one or two clicks away.
However, casual apps have almost opposite requirements! They need to be non-intimating and simple. Simple is at odds with quick to use IF the use case is complex. Simple and quick to use can ONLY coexist in a scenario that is simple in it of itself, i.e. not a pro app but a simple app.
The end result is usually that I've been distracted for no reason.
In a casual app, none of this matters as much.
Trade offs, as usual.
In a Jetpack Compose app I wrote, I created generic "error barrier" components, so that error messages display over relevant parts of the app, with just a few lines each time, timeouts included. I think this is the best approach, easy for developers and informative for users. Too many apps just ignore errors.
Less code, centralized messaging.
Toasts are a global UI feedback mechanism for non-blocking/fallible/undo-able actions. That does make them out-of-place by default, but at least consistently so.
A solution I'd accept is local-view-first with toasts-as-fallback when the view is dismissed. That said, loading indicators _might_ make users hesitant to dismiss a view.
> optimistically show the user a success result?
I don't particularly like React, but this a core feature of such JS frontend frameworks, optimistically "succeed" while async network and back-end work happens to give the illusion of speed: https://react.dev/blog/2024/04/25/react-19#new-hook-optimist...
I don’t have any strong feelings one way or another as long as there is proper inline feedback.
Basically, the user should be able to configure toast messages; they should not autohide, or the time they hide should be adjustable, or they should be extendable within 20 seconds. TL;DR, self-hiding messages, dialogs, etc are not good for a11y.
That said, the toasts have a button where the user can undo the action taken, which is good for accessibility under criteria 2.5.2 and/or 3.3.4 / 3.3.6
>But I don't want so many mails in my inbox
Then write mail rules. It's really easy and personally I couldn't survive at work without them. That's a big part of why it's nice: You can choose how it works unlike practically everything else these days.
https://m3.material.io/components/snackbar/guidelines
https://developer.android.com/reference/android/widget/Toast
Material Design Snackbars aren't toasts:
* Snackbars are local, toasts are global
* Toasts don't receive focus, snackbars can (via the optional action)
* Toasts auto-dismiss. This is optional for snackbars
* Snackbars can explicitly be dismissed early by a user
> 1. Add inline feedback
>
> Information in auto-dismissing snackbars must also be communicated using another accessible method inline or near the action that triggered the snackbar.
Go to https://www.youtube.com/feed/history and click "Comments" on the right side. Then delete one comment.
You will get one toast indicating that it will be deleted, and one a second or two later indicating that it got deleted.
If you delete multiple comments quickly one after another, you'll first get a bunch of toasts indicating that the comment will be deleted, and then, with that second or two delay, each confirmation, but they do get deleted sequentially, so you have to wait for all the confirmation toasts. Which for a deletion of 10 comments will take more than 10 seconds, even if you clicked them all in two or 3 seconds.
Same with the live comments at
https://myactivity.google.com/page?page=youtube_live_chat&co...
A confirmation toast with a page-redirection is a great way to add additional indication to the user that their submission was successful.
A warning or error toast in addition to standard form validation indicators gives a great secondary indication to the user that they need to change something.
And if implemented in a catch-all for nonspecified errors, it'll allow the user to preserve the state of their page vs rerouting to an error page.
If used as one tool in the toolbox vs the only tool in the toolbox, it's a great option.
I disagree with this part, at least in general. Having an Undo is very good if you have accidentally clicked somewhere and don't know precisely where, and you don't know the application well enough to easily undo based on the message alone.
That's false. The checkbox itself is not a viable undo button under any circumstances in this specific example (i.e., you accidentally clicked but have no idea where, and let's assume you have no idea of that particular checkbox's state prior to the accident). Any adjacent checkbox would have extremely similar plausibility for a user wondering how to undo.
That said, toast is not great either, because it may disappear before the user fully recovers from their accident (say, a spilled drink). Maybe the undo button (and any async success/error labeling for the original event) ought to be adjacent to the checkbox and persist until the next action taken.
That the same for every single checkbox in every single form on the Web.
Even in the unlikely case in which you clicked on the lists button that opens the popin and then accidently clicked on a checkbox without seeing which one and without seeing the checkbox state change, you still have the list of lists on the screen and you can still choose if you do want this video in this list(s) or not.
In my experience, the majority of forms on the web don't commit until you decide to submit, so if you have an accident before then, you can recover (well, buy a sense of certainty at the cost of redoing some work) by reloading the form. In contrast to that majority, here we're talking specifically about forms where each component auto-submits immediately. I think that if a component auto-submits, then anything related to that submission (success/failure status, undo, etc.) should be presented within that very component.
I don't think a toast or any confirmation feedback mechanism is supposed to replace a log or undo list.
This can all be fixed. E.g. disable the checkbox while it’s processing; or show a small loading indicator; make it impossible to click the checkbox repeatedly. Etc.
A frontend update that doesn’t wait for the server is nice, but only when server state is irrelevant. If the user wants to know about the server state, then the UI should always indicate that.
To illustrate the problem with "perfect storm" example, suppose a your back is turned and a ball rolls of the shelf and hits the keyboard. Did anything change? What changed? How do you fix it?
Did you just archive or delete a couple of unread emails? You may never know!
There's nothing more infuriating than going to click undo and the toast disappears.
I don't think designers should put anything interactive in an arbitrarily timed interface aside from "Dismiss". A toast is the best when it's displaying what is currently going on, not as a pop up dialog box.
The best design for Undo I think is to make it a dedicated button, like the one in the text editors. When user clicked "Archive", a Toast pop up and displays message "Archiving N entries, please wait" and then change it to "N entries archived. You can press Control+C or click [Undo Icon] to undo if that was a mistake" then the Undo button lights up.
Also, IMO the message format "Archiving N entries, please wait" should be a standard, it tells the user in a clear way 1) what the software is doing, and 2) what should I the user do. On the other hand, the message "Conversation archived" don't really provide the same value, since user already saw it happened.
- if your app has a number of messages (eg: “image downloaded” or “message sent” or whatever) then there is a consistency in using toasts as they all appear in the same predictable manner
- often “appear away from focus” is one of the intended goals of a toast; it’s a message that is present, but more in the periphery (the user can ignore in most cases, and it doesn’t obscure main content)
Any feedback from a user action should be done within the context of the user action. If the action is async, it should be clear and the feedback should instantaneously indicate that the action is queued for processing. In that case, the feedback should give 2 options: cancel and access the queue (or better give a vision of its progress ).
If I removed a task from a board, I can't show - on the task - how to undo that action. There's a keyboard shortcut to undo it, but how would the user know, visually?
I'm not going to replace the task with a note because notes don't belong in task lists - only tasks do. I'm not going to come up with some derivative task that only displays a message because then I'm injecting intention that has no function for the task component. I'm not going to just not tell the user because while it is obvious that the task was removed, it's not obvious how to undo what could be an alarming action from a single click (and I'm certainly not going to nag people before deleting a task with a single click; it's a core functionality of task lists. It needs to be able to be done instantly, and undone instantly).
So on and so forth. I'm sure people have tons of one-off, little, anecdotal examples like that. Toasts were invented for a reason. Just because people got cutesy with them doesn't mean they aren't specifically useful for specific scenarios, regardless of how contrived.
My case is a reference to a real-life, literal sitaution that I was involved with. The "opinions" expressed as why I would or would not do certain things had PLENTY of A/B testing and research done on them. Not only internally, within my company, but externally out on the open internet. Nothing I said conflicts with extremely common understandings of these UX patterns. And, far more importantly, our internal testing and research backed all of our findings up.
So when someone says "here's a better way to do your UX", they are specifically saying that they have some insight that beats out all of the research and testing I have seen on it. In which case, I am MORE THAN HAPPY to see any of it. I love to learn that certain patterns don't work the way I thought they did! Sometimes it just means they've gone out of style and we need to update with a trend. I'm very interested in making UX the most reasonable I can for the most users. So if I'm doing something wrong, I'd love to see data to support that!
What is less interesting to me is someone saying that their opinion is better without any evidence of that claim. But, hey, I'm open to new ideas: please explain to me what concrete actions I should take based on the reply I got? I should go research it because ne said it, even though it's a very common thing that is said in these discussions and I've never seen it supported? Do you chase down every single lead without asking for the minimum amount of effort to be put in by the propositioner? If this person was earnest about helping me achieve a better UX, rather than just stating their opinion out loud, why is it difficult to follow up with practical data?
The difference is, I didn't say "Here's a better UX". I said "This is an appropriate use for the UX". I didn't back it up with testing because I wasn't saying anything that needed backing up. I wasn't making a value statement, or insisting on a quality of the UX; I just said that toasts were appropriate for certain functions - not that there was no better way to handle the UX.
You, on the other hand, absolutely did make a value judgement. You said "better". And okay! I'm fine with you having a better UX! I'd love to know more! Please, provide any information you have on why yours is better!
If you need more help deciphering the difference: I was arguing against the blog author's EXCLUSIVE argument ("actually, this is appropriate, so it's not that toasts are NEVER good UX"). You are arguing for your own EXCLUSIVE argument ("the good things about this way aren't available with your way"). If you don't understand why exclusive arguments merit more evidence than arguments for maintaining inclusion (as opposed to changing to be more inclusive), I'd recommend boning up on formal logic.
If value judgments trigger you so severely, it could be healthier to log off and read a book instead.
In an informal conversation, it's common to voice an opinion and present an argument. It's also common for other participants to disagree and voice a different opinion.
Informal conversations can actually be wonderul, you should try!
I said a thing. You said a thing. I gave you honest and apathetic feedback. You're the one that got defensive about that. You could have left it there; you could have said "oh, I've got nothing formal, I'm just talking about case X, Y, and Z, as brought up in article W."; you could have done anything other than take it hard. Instead you got pissy about me not caring about your unsupported opinion (I make no value judgement on whether it's actually good or bad; just that it's unsupported).
I'm sorry that my immediate response, in informal conversation, is less charitable than you prefer. I don't have any interest in arguing about stuff that has accessible points of well-supported data. I prefer to argue about stuff like art and flavor and preference and anything that doesn't have some reference-able data to make one side or the other impractical to support. If you want to talk movies, or games, or food, I'm happy to volley back and forth about the "better" and "worse" things. But if you want to "argue" that you know of a way for me to do my job "better", I cannot stress this enough: I would LOVE to see your data. Because it will help me do my job better. It's not facetious; it's not smug; it's not a spit in your face. It's an honest offer for you to either provide something that does what you say (at least in your opinion!), or to leave this topic with me. There's nothing tempermental or nuerotically formalized about politely offering a path for the conversation, should it continue. You should try just ignoring the path if you don't want to walk down it.
When talking about UX, I am expressing an opinion based both on my experience as an engineer and as a user. In this case, I can state that something is better, at least in the sense that it's a more intuitive and an effective pattern.
If judgments like that trigger you - that's ok, I don't have to meet some unexpressed level of data-supported evidence.
> There's nothing tempermental or nuerotically formalized about politely offering a path for the conversation
Re-read your responses and imagine talking to someone in person with this level of nit-picking and animosity.
“You’re not wrong, Walter..." and so on.
There is no context for this, and often an action is required. And even if not, it is certainly useful to confirm with the user that their action was detected.
Where should that feedback be given for modal operations, acknowledging that 99% of the time when the user initiates the action they want to background the operation and move on to doing other things?
Says you, but why? There are many workflows where this would be an unnecessary slow point in the user's work.
It's all about balance. If 99.9% of the time a non-instananeous operation will succeed, and the user has faith that it will succeed, leaving the modal up is a terrible UX. But quietly notifying them on success might not be.
Because otherwise I wouldn't be able to get it back. But if I have some kind of temporary hiding feature, I can easily use that as soon as I notice that the operation hasn't immediately completed. (And again, the common case should be that it completes immediately.)
And if something isn't supposed to be instantaneous, I hold that the interface shouldn't be modal anyway.
A toast notification doesn't preclude being able to recover state. Email applications still have an Outbox and Sent folder. A UI that allows you to place orders can still have a Pending Orders list.
> (And again, the common case should be that it completes immediately.)
In the real world, not all operations initiated by the user can complete immediately.
> And if something isn't supposed to be instantaneous, I hold that the interface shouldn't be modal anyway.
Why not? The two things are orthagonal. Collecting information about the user's intent and acting on that intent can often have differing workflow implications and timings.
Blanket rules are almost always useless in UX. Say you have an interface made to place an order. You collect a bunch of details about the order modally. The user confirms and submits the order. But it'll take a minute or two for a vendor to confirm it. What should happen next is COMPLETELY dependent on the context of the application. If this site is where the user is ordering dinner, it makes complete sense to leave the user in a modal state until confirmation occurs, because it's unlikely they're going to be placing another order for dinner immediately after, unless the first order fails. If this site is made for a procurement professional placing 20-30 orders one after another, it makes complete sense to background the confirmation and report status non-modally.
No. Growl came out in 2004, Windows XP had notifications in 2001. If you consider Clippy's messages notifications, we can go back to at least Microsoft Bob (1995)
As a backend developer this stuff is mind-boggling, just call it "notification widget", or a "confirmation widget" etc.
Try explaining what toast is to an Indian subcontractor who has never eaten toasted bread in their life and then apply that to the UX usecase.
Removing these terms will also improve accessibility and understanding for junior developers entering the frontend world.
"P-trap" is a confusing word that plumbers use, we should instead have them say "gas barrier". And the word "fuse" makes very little sense in an electrical context—try explaining to someone who's never seen a stick of dynamite why the "overcurrent stopper" is named after a long gunpowder-infused cord! Traffic engineers shouldn't refer to "groups of cars" as "platoons" (they're not in the military!), and software developers should stop talking about "DDOS" and just say "lots of computers hitting my server at once"!
In all seriousness: jargon exists because it's useful to be able to refer to something that you use a lot conscisely and precisely. Your proposed replacements are not concise or precise, and they only solve the non-problem of people not understanding the etymology of the jargon. Part of learning a trade is learning the jargon associated with it, and that's true for every trade.
Your example of a "P-trap" is good but its not like plumbers are going around saying, get me the "slinky hotdog" to bend a copper pipe, or you need a "banoffee pie" to seal this joint.
For example in Google
"toast"
"toast menu"
"toast ux"
All yield different results
However "p-trap" gets you a narrowed list of results
Again, it seems like you're inconsistent in applying your frustration with jargon. You're frustrated with jargon in an adjacent profession to yours, but don't seem to apply the same logic to professions that are entirely unrelated or to your own jargon.
To a front-end dev or designer, it does. That's who the jargon is for.
I've heard of "hero pictures" (detailed close ups, I think named via the highest quality film props), but not food or other UI uses.
How would you call a hamburger menu? "menu widget with three-or-sometimes-a-different-number-of little horizontal lines"?
As a backend developer you also have some jargon but you’re too used to it to notice it.
Menus are supposed to have titles so that you know what's in them, not just that there is something in them. It's especially obnoxious to see a hamburger menu next to other icons that happen to be for other menus. First off, this fails to convey that they even are menus, and not, say, buttons. But it's especially obnoxious trying to guess what menu items the hamburger menu might contain. Even if you decipher the other icons, you're left with speculating about all conceivable menu items, and then applying process of elimination.
Since the name arises from use by a hero, then to extend the metaphor by direct analogy, the actual hero is the overall article/content in which a hero image is contained.
That said, a "hero sandwich" is that which "one needed to be a hero to finish" [1] so does all tie back to the idea of heroism regardless.
[0] https://en.wikipedia.org/wiki/Prop#Hero
[1] https://en.wikipedia.org/wiki/Clementine_Paddleford#Writing_...
For undo-able actions, toasts disappearing too fast or colliding with other toasts badly is a real problem. An affordance to see the toast history with non-disappearing undo buttons may be more to implement but for a lot of apps, a viewable and editable history combined with toasts is a much better UX than either system on its own.
> But by archiving the email, the email disappears from the list, which already implies the action was successful.
> In this example, the button already includes a confirmation so the toast is entirely unnecessary.
I vehemently disagree with the idea that just because you're already communicating something one way it's bad UX to include another way of communicating the same thing at the same time. Redundancy in communication is a feature, not a bug, and it's present in all human languages. It ensures that even in less than ideal conditions the message still gets through.
In the case of toasts, having a single, standardized way of communicating the status of all actions (and if possible providing the undo) allows a user to quickly pick up on the pattern. Extra indicators closer to the action can be valuable too, but it's when they're paired with the toast that their meaning becomes entirely clear. To remove the toast in favor of a bunch of specific indicators is to force your user to learn several different ways of saying "it's done now" entirely from context (many of which will be small and subtle as in the examples given). This might work fine for you and me but isn't great for, say, the elderly or the vision impaired or children.
Unless they're actually getting in the way, toasts aren't bad UX, they're redundant UX, and a UX designer shouldn't be striving to optimize away redundancy.
But the proposed solution is clearly worse, unless the loading circle turns into a tick to show completion
Taking the YouTube example, the checkboxes are 100% optimistic while the toast notification indicates that the request to the backend that was fired off asynchronously was successful. With the archive message example, it is the same thing. The message is removed from the list optimistically and the toast message is representing that the message was actually archived.
I would much rather only get the toast if there is a failure to commit the change. Generally, them flashing up is a distraction from what I’m trying to accomplish. And being far on the screen from where I’m taking an action makes them even more of a distraction.
I can see the argument that there are certain places where people use toasts that are unnecessary and provide information that the user doesn't need. But that's not the same thing as toasts being bad UX in the general case.
Not if they go away, and take their “[View item]” button with them, before you've had time to read the notification, decide if you want to click the button, and actually get your cursor there to click it.
Which they usually do. So nyaaah, dubious benefit.
Maybe your browser should could have an icon for same instead making it more standardized across different sites.
https://en.wikipedia.org/wiki/Pop-up_notification#JavaScript
Ask for everything get nothing. I imagine most people click no
An action/activity log is just a reverse-chonological log of things that happened. You could make one by recording every would-be toast and putting it on that list, complete with a timestamp, and any of the context-relevant action buttons (like "undo", or "view item", etc.). The list should be a fixed recording[0], without any way to dismiss some or all of the entries. Add some attention-grabbing indicator whenever something is added there, and you get all the benefits of toasts with none of the drawbacks: the log lets you report completion of optimistically-executed actions, provide place for context-relevant buttons, and also is accessible, can be browsed at uses' own time, improves discoverability and learning, and can be upgraded to also enable undo feature.
--
[0] - Well, appended from top, and possibly unwinded by undo. Users understand that. Can't be append-only, because mixing that with undo gives you the undo system from Emacs - very powerful but also nearly incomprehensible to most people.
The problem with notification only of failure is that one is left uncertain about success, though I would agree that striking a balance between distraction and uncertainty is difficult.
For the checkboxes, I'd say GitHub nailed it: for settings that are applied instantly (e. g. https://github.com/settings/appearance), they show a spinner and then a single checkmark right across the section title. (It used to be next to the input element – both ways are fine, I think)
But that's less a problem with getting notified or not, and more a problem with software not doing what you've told it to do.
E.g. you can take action A on your laptop, followed by action B on your phone. Undoing action A may not be easily possible if it was followed by action B.
To make that work properly you need to activel sync states between all the users devices using e.g. websocket or what-have-you. Handling edge cases becomes quite the nightmare, e.g. phone has poor connectivity.
Only the big guys would have budget to do these sort of things (And make them work well).
In other words, if you delete an email and it goes to the trash folder: good use of toast + undo
If you empty the trash, and there is nowhere the user can go to unempty it: bad use of toast + undo
Its also useful as a sleight of hand eg when cancelling an action you havent yet taken (which actually is generally what a toast + undo actually is). The best example of this being toast + undo for an email send
- Put cause and effect close to eachother - Don't block my view based on mouse position. I hate video players that ofverlay the pause button when the mouse is over the video, or images that get obscured by some overlay when hovered. My zoom follows the mouse, so I can't move what I'm looking at and where my mouse is pointing independently.
Agreed. This is exceptionally annoying! Who thought this was a good idea? Why don't people copy proven video interface behavior from Google. Why go out of your way to annoy your users?
I get the annoyance, but especially on mobile, it conversely helps if you want to advance the video by as few frames as possible to catch a freeze-frame gag or something like that. If the UI immediately disappeared upon resume, you'd have to triple tap to immediately pause the video again. (On desktop you can just mash the keyboard or even use a dedicated "advance one frame" key, but on mobile that's not available.)
This shit is super annoying for everyone. Even people who do not use magnifiers. Who decided that this was a thing to do and why? I would like this pattern to meet sudden death.
But wouldn't this situation be even worse with a failure-only toast? A request timeout could happen 30 seconds after the fact. You're likely in a very different UI state at that point, and unless the error message is very specific, you'll have no idea what even failed if you are quickly performing lots of actions.
You don't want to stack them, or if you do you need some sort of inbox for them. You don't want to be spammed by them, you don't want them used as a stand-in for representing object state.
For a checkbox, I'd rather the info be communicated "inline" maybe by color/shape/shading. A toast could be used like an info popup, perhaps i.e. "why did my checkbox get reverted".
Or it could be for a high priority event, that just doesn't fit (well) in the current screen. But, again, care should be taken.
If you communicate with your user, don't spam them - provide them with prompts and visually appealing methods to obtain their data. Toasts can be a part of that but shouldn't be the first tool reached for (ideally). I think the reason they are so dangerous is because they are outside the main UI flow, its technically and visually "easy" to use them.
Now my presence is to use this grade A type of implementation because I like very solid software and I’ve done it so many times now that I can bang it out in a coding interview. Or explain it to a team so they can implement it.
But your average app is like a grade D. Even Instagram or Snapchat where I’m never too sure if my stories are going to be in order if my connection fails or even though it lets me cancel an upload, if I do it slightly too late the app fails to cancel because it can’t keep track of its own state through a state transition.
So for 99% of apps, I want them to put a redundant toast. I do not believe they can build solid software with proper state management. At least the redundant toast lets me know it did go through. A lack of toast doesn’t mean it went through because some people barely can implement error handling.
I would much rather the sequence of commands issued through the ui be a declarative state change queued until committed without bugging me about an error I can’t directly fix. Toast that backend chaos monkey, not me.
Wanted to mention in case you're not aware and maybe there's some tool somewhere (or some way to configure a screen reader?) so that you can keep your simple zoom workflow but still benefit from the ARIA alert pattern.
[0] https://www.w3.org/WAI/ARIA/apg/patterns/alert/
For a small regional golf court chain who want to build an online tool for reserving tee times? They most definitely won't have the budget to do things entirely properly.
There was some discussion in the article and elsewhere in the thread about how a toast with an undo button could be a very useful interface pattern. It wouldn't work for me, so I would hope that UX designers that want to use toasts would also design in other means to find and execute an undo action.
For you, my comments reinforce that toasts are "good UX" when they contain redundant information. I'm warming to the idea. In parallel, for me, this discussion is reinforcing my intuition that "actions and feedback as close as possible to the area of interaction" should be considered the primary vector.
The issue with the not seeing toast notifications is that in some apps it’s the only true notification that the request went through to the server so missing them when they failed for whatever reason is rather annoying
In other words, it's a crutch that is often taken when there isn't enough budget/resources to make a proper UI (Or enough care/love/interest/skill).
I have definitely myself gone down the quick path of implementing only server side validation + toast service for projects where the customer just does not have the budget to do things entirely properly.
A toast makes sense as a worst-case, last-gasp, no-context attempt to communicate with a user. In this example, if the user unchecked a playlist and dismissed the list of playlists while the save was happening, and then the save failed, a toast makes sense because the context of the action is gone. Might as well put the information at a random spot on the screen.
Even then, a toast probably isn't the best you can do, if you really want the user to understand the error. In a the-user-is-the-product adware application like YouTube, you probably don't care if the user misses errors like these (and might even prefer that they do), but in a business application you wouldn't want to gamble on the user missing the toast or confusing it with a different error. It might be more helpful for a normal user if you re-open the element and show them the error in context. Open up the list of playlists and animate something to draw their attention to the fact that their change didn't save. I'm probably getting pie in the sky here, because that sounds really difficult to do in a systematic way, but in an ideal world, you'd always see errors in context.
Taking the archive example: yes, the disappearing message successfully indicates that something happened. But it doesn't tell you if the message was deleted or archived, and misclicks are common. The toast unambiguously communicates what happened in addition to saying that something happened.
Additionally, I stand by my argument that consistency is valuable. By all means have in-context feedback, but also pick a standard way that you always use to communicate completion of all actions. It makes it a lot easier to understand and eventually make use of the in-context feedback which may not be as intuitive as you think it is.
But adding a toast isn't free. It's a distraction, and arguably a pretty intense one for ND folks -- especially when it becomes a standardized message center with multiple items queued up.
In many cases the most useful toasts would also be better if they weren't toasts. For me, the most useful toast I interact with also demonstrates why toasts are bad UX: creating a new ticket in Jira. Since that can't happen instantly, it needs a delayed message to let you know when the ticket is created and you actually have a URL to open. A toast is useful in this case, but it's also far from optimal, because for some reason it's going to disappear in a few seconds, and it also won't tell me how many seconds I have left to read it.
Why would distraction be the primary mechanism? We figured out decades ago how to put a button in the header that opens a messages feed which the user can read and dismiss at will. While it's possible to implement such a feed badly so that it's annoying, it's difficult to implement toasts in a way that aren't annoying. Maybe even impossible.
Diagnosed with ADHD, so I'm guessing an ND folk here: modern applications in general, and webshit in particular, give me huge anxiety because of all the eventual consistency and optimistic actions bullshit[0], coupled with flakiness and bloat of entire modern software stacks[1]. Maybe "toasts" aren't the bee's knees, but they work as lagging indicator that something happened that I otherwise wouldn't notice, and in some apps even lets me undo the unwanted operation. That does a lot to relieve my anxiety and help me use software with less frustration.
--
[0] - That itself is a big antipattern. Software lying to user about its state is a form of gaslighting; it makes interaction more error-prone, and prevents users from building correct mental models of the application and its interactions with other systems.
[1] - My Android flagship lags often enough on taps and drags that every other day my input gets misinterpreted and does something unwanted. Similarly, I type faster than most software - webshit in particular - can react, so e.g. a small jitter can turn "ctrl+t n e w s <ret>" into "ctrl" (held, released) and then "n e w s <ret>", which does $deity knows what in the current tab.
All things that a message log does better than toasts!
I'm also ADHD and, like OP, I appreciate having the stream of toasts that lets me know what the software did. It's saved my butt a bunch of times when I accidentally do something I didn't mean to (deleting instead of archiving, for example). A message log would just get ignored, but toasts help a ton because they're visible.
This. Also true for both my wife and me. One of the worst offenders here are contact forms - it's increasingly rare you get any copy or confirmation via e-mail that your message was actually recorded, so once you submit the form and see a success page, you really can't be sure if your message was delivered, or even if it left your browser in the first place. Takes one little JavaScript fuckup for the message to be lost, and your only indication may be an error message in development console.
Related, at one of my previous employer's, there were some documents I was interested in that had restricted access; when trying to open them, I'd get an access request form asking me to provide a reason. I filled it several times over couple of months, but never got any reply. Then one day, I mentioned it randomly to my boss, to which he told me that this form just goes straight to /dev/null...
Redundancy in UX confuses them. The closer you can get to the whole UI being a single sentence and two buttons the better.
> The closer you can get to the whole UI being a single sentence and two buttons the better.
Sure, but this is kind of my point—clever UX tricks to communicate things without words don't work for them. A toast is valuable for the tech-illiterate precisely because it uses English text to communicate its point, and having it exist in the same spot for every action makes it easier for them to pick up.
It's not the be-all end-all of UX design for the elderly, but it's a heck of a lot better than the alternatives proposed in TFA.
Things disappearing with insufficient explicit feedback for what actually happened to the things is one of the most common issues I've encountered with older computer users. I think it's the most common issue. Toasts add persistency and visibility for users who barely or don't understand the UIs they're interacting with, which makes it easier to understand what happened.
If Outlook gave feedback to every user action in a toast, then provided a universal history of every toast, you would probably resolve a significant amount of issues caused by user actions leading to unintended changes (and being unable to recognize that the action lead to a particular change, or even how the current state differs from the previous one).
This is what message feeds are for. Toasts are just a worse implementation of message/notification feeds.
That would make me utterly crazy. I couldn't use an application that did this.
Toasts appear somewhere in the corner and then disappear very quickly. Not sure how useful that feedback is. It's distracting at best.
It's time to stop blaming "age" when the more likely explanation is EXPERIENCE. Many people learned to use computers in an age of well-understood GUIs that hewed to standards that evolved for very good reasons. For example, buttons that were depicted (in a clean, not cheesy "skeuomorphic") manner. You can tell at a glance if a well-depicted button is on, off, or disabled.
Then enter the idiotic "flat" design fad, where the entire screen was an Advent calendar of no controls at all... or is it ALL controls? Click on every piece of text and every rectangle to look for the hidden goodies.
Those conversant in (and tolerant of) more-recent UI have simply become accustomed to shitty UI. They've either forgotten how bad it is, or grew up not having experienced good design. Another great example that has disappeared in many areas is GREYING STUFF OUT. If something is not currently usable because it's not applicable, you don't just make it disappear. You grey it out, so users can learn
1. That the function exists 2. Where the function resides 3. What conditions must be satisfied to make it work
This discussion tells me we have not yet reached perfection in UI! Toasts are good for me, but definitely not good for the users you and others have described.
My hope is that small AIs inside UX can help here. Can you tell your UI framework something like, "Give them a choice between X and Y." and then "Clearly indicate they have chosen Y." (with a fallback of "Tell them something went wrong, and they won't be able to make a choice right now after all.")
Or is it simpler than that, and we don't micro-manage the AI-powered UI engine? "Get answers to these questions, and submit them to this API." — and UI engine does all the rest? I'm not sure.
Anyway, an improved UI would adapt to the user — think of the way a person providing a service adapts to the customer, intelligently and empathetically. For example a teacher watching for signs of understanding in a student, adjusting explanations. A car salesperson being quick and businesslike with one customer and listening patiently to another.
The toast makes it clear.
I completely agree with you.
The article kind of confirmed to me that toasts are good UX.
In general, I think the best use of toasts are to present options for further action (if needed).
Take the example of deleting an email and getting a toast that lets you undo. Your action has already been completed and you can see it. But you have more context that can be acted on. In this case it's not redundant, even though it relays the action you just take.
In this scenario, it's ideal to move this away from the viewport the user was in. In most cases, they don't need it. But if they do, it's onscreen.
Simple confirmations that do nothing else are redundant. But toasts don't have to be used that way.
It's bad UX. Put your damned messages where my attention has already been directed to BY YOUR UI.
We can have an indicator, then some icon or even a green bar in the "save this" modal, just fine. Or we can make the "archive" icon color different, or add an error, an undo-button, or other message next to it if we really need to convey this information. This could be a tooltip, something in the icon-bar, or anything really: as long as it right at the place where I made the change and expected the change to show up.
User notifications on MacOS are definitely standardized, but originally they were Growl notifications until Apple made it a first-party API and iterated on it.
And you are right in that the Growl-style notifications in Mac OS are standard now... but those are different from the ones in question here because they are not related to a control that the user was just manipulating. They could come from anywhere at any time, and thus they must be presented in a location independent of whatever the user is doing.
The Growl-style notifications work well because they're near the top of the screen, too. Users are used to status and information in menu bars and so forth, in accordance with the general top-down convention of presenting information.
Thinking it through, I did actually implement a "toast"-style alert for asynchronous issues in one application. It was at the top of the screen, though. I originally put it in there strictly for debugging, but I think I might have left it in the release. So I'm not entirely opposed to the idea, but mainly its placement in the examples discussed here.
It's pointless pretending there's one perfect guiding philosophy and all others are obviously wrong.
I believe toasts should be confined to this scenario I'm describing, and indeed feedback directly coupled to user focus/input should be located near to that as you say.
Ok, so where does the toast go if you've already scrolled or otherwise navigated to a different area of the UI? These optimistic updated could take multiple seconds to succeed, and maybe as much as 30 seconds to fail.
Not to mention that, if the operation fails, isn't it likely that the user will want to re-try? And that'll require access to the original control in all likelihood.
If the user scrolls away and the information is important, use a modal alert.
These toast notifications just are a bad solution. I often miss them, because I'm, you know, doing work, not scanning my monitors for notifications I mostly don't care about. (Redundancy is not harmless. Redundancy also trains me that your messaging is mostly noise.)
Yeah this in particular bothers me. Someone that knows UI and UX should also know you can absolutely remove something on the front-end without a corresponding action on the back-end. If I click archive and the email disappears, that doesn't mean the back-end call succeeded or has even been made. How many times do you click move/delete/whatever in an app, the thing moves or disappears then a second later pops right back in? These things happen and the subsequent alert that it was actually successful is a good thing in my opinion.
Their examples are all arguments of where local information should have been displayed. I agree with them in general. I just think that a toast should also be displayed in each of the situations they identify.
What seems to have happened is that they correctly identified a problem with lack of local information and blamed it on the presence of non-local information, which is fallacious. You can have both, and I believe that a UI with both is generally more usable.
As long as it can be disabled. I find toasts to be actively bad and don't want them to happen at all.
And yet the discussion here seems to veer off from actual verification of whether toasts actually work, and all the discussion seems to be purely speculation. Granted, there is general argumentation too that's valid to some degree, and it's good to present that, and at the end of the day the only actual data that can guide this decision for a given user interface comes from user testing that is highly context sensitive.
Why? Because there exists no general answer to this question at all. It depends deeply on who your users are, and before the industry understands this basic fact that we as a species are mostly incapable of predicting what different persons from a different user group point of view will be, usability testing will be critically needed, and until we actually start doing it, we will keep creating user interfaces that marginalize everybody but ourselves.
They are redundant as in superfluous not as in a back up.
Too much junk information trains users to ignore them, which leads to hilarity ensuing if there also is valuable information every once in a while.
Moral is don't send information to a user if it's not strictly necessary.
Further reading:
https://en.wikipedia.org/wiki/Banner_blindness
https://en.wikipedia.org/wiki/Alarm_fatigue
https://en.wikipedia.org/wiki/Inattentional_blindness
https://en.wikipedia.org/wiki/Habituation
Take a breath