Glad you asked! ;) The comparison is with gestures, which are not self revealing. Linear menus don't support gestures, selecting without looking at the screen, mouse ahead, display pre-emption, or rehearsal, the way pie menus naturally do. Pure gestures don't support browsing, reselection, or error correction, and they don't make efficient use of "gesture space".

Pure gestures alone (like swiping in different directions on an iPad or phone, or the more complex unistroke gestures for writing letters, numbers, and symbols in Palm Graffiti) don't have a natural way to reveal themselves or prompt the user which gestures are available and what they mean, or a way to train users how to use them quickly with gestures.

Pie menus also support "reselection" and "browsing", so if you make a mistake or change your mind, you can always correct your gesture in-flight, and you can browse around pie menus to reveal feedback about each item (i.e. text in the item or menu center, or immediately applying the currently selected item to the visual state of the application, previewing the effect of the selection without committing it yet, so you can still change or cancel it).

Users learn to use pie menus in three stages: pie menus lead, follow, then get out of the way. This is called "rehearsal", because each stage naturally and transparently trains you to move on to the next stage of expertise. So the novice's time using pie menus in the "leading" mode is not wasted, but trains them on to the "following" and "getting out of the way" modes.

At first, a novice user clicks the button or presses and holds to pop up a menu, then looks at the items, decides which one they want, moves the mouse in that direction, then clicks again or releases the button. That's leading, and it's self revealing.

Then a more experienced user who remembers the direction of the item they want clicks or presses then moves in that direction (mousing ahead but waiting for feedback before confirming). They wait for the menu to pop up, look at the screen to make sure they're selecting the right item, then if it is they click or releases the button to confirm, or else make a correction. That's following, where pie menus reveal themselves showing the selected gesture, then let you confirm the selection if it's right, or or change it if it's wrong, giving you more confidence to move on to the next stage.

Finally an expert user remembers the direction with confidence, then smoothly clicks or presses, moves, and clicks or releases, in one quick continuous gesture, to select the desired item without even needing to look at the screen. That's getting out of the way. That's where "mouse ahead display pre-emption" is useful.

Compare that with linear menu keyboard shortcuts that are a totally different physical action than selecting from menus with a mouse, so selecting an item from a linear menu with the mouse (novice) is not rehearsal for using its shortcut with the keyboard (expert), and that does not train your muscle memory by rehearsal to smoothly move from novice to expert, the way pie menus do.

Pie menus should support "mouse ahead display pre-emption" so that when users select from them by gesturing quickly without hesitating, they don't even bother to pop up the menu, just provide some lightweight unobtrusive feedback like showing the item label next to the cursor in a tooltip, instead of popping up the whole menu and covering up other windows.

The mouse-ahead stage doesn't require a high-cognitive-load attention-grabbing hand-eye feedback loop, so you can "mouse ahead" the same way you "type ahead" without hesitating between every keystroke and looking at the screen and waiting for the character you typed to draw to make sure you typed the right character, before typing another one.

Imagine how slow it would be to type, if none of the keys had "self revealing" labels, and after pressing each key you had to stare at the cursor and wait to see if each key you pressed was correct before pressing another key, instead of focusing your attention on something more important while touch typing.

That's exactly what linear menus force you to do, but pie menus don't. You need to look at the screen to make sure you're pointing at the right linear menu item before confirming (which unfortunately has an extremely small target area compared to the area of a pie menu slice, which extend out to the screen edge), but not with pie menus, because they're directional. And each pie menu item is also the same distance from the cursor, instead of each being further and further away.

The following article discusses "gesture space", and how pie menus are superior to gesture recognition systems like Graffiti, because every possible pie menu gesture has a distinct easily understandable valid meaning, clearly separated from every other possible gesture, with a uniform maximum possible target area.

It is not possible to make a syntax error with pie menus, while with a gesture recognition system like Graffiti or normal handwriting recognition, most gestures are syntax errors, many gestures are close to other gestures in "gesture space", and all gestures have a much smaller "area" in gesture space than pie menu gestures. (Because pie menu gestures saturate 100% of possible gesture space with meaningful gestures, while handwriting recognition squanders most of gesture space on syntax errors.)

https://donhopkins.medium.com/gesture-space-842e3cdc7102

>Gesture Space

>The space of all possible gestures, between touching the screen / pressing the button, moving along an arbitrary path (or not, in the case of a tap), and lifting your finger / releasing the button. It gets a lot more complex with multi touch gestures, but it’s the same basic idea, just multiple gestures in parallel.

>Excerpt About Gesture Space

>I think it’s important to trigger pie menus on a mouse click (and control them by the instantaneous direction between clicks, but NOT the path taken, in order to allow re-selection and browsing), and to center them on the exact position of the mouse click. The user should have a crisp consistent mental model of how pie menus work (which is NOT the case for gesture recognition). Pie menus should completely cover all possible “gesture space” with well defined behavior (by basing the selection on the angle between clicks, and not the path taken). In contrast, gesture recognition does NOT cover all gesture space (because most gestures are syntax errors, and gestures should be far apart and distinct in gesture space to prevent errors), and they do not allow in-flight re-selection, and they are not “self revealing” like pie menus.

>Pie menus are more predictable, reliable, forgiving, simpler and easier to learn than gesture recognition, because it’s impossible to make a syntax error, always possible to recover from a mistaken direction before releasing the button, they “self reveal” their directions by popping up a window with labels, and they “train” you to mouse ahead by “rehearsal”.

[...]

>Pie menus benefit from Fitts’ Law by minimizing the target distance to a small constant (the radius of the inactive region in the menu center where the cursor starts) and maximizing the target area of each item (a wedge shaped slice that extends to the edge of the screen).

>They also have the advantage that you don’t need to focus your visual attention on hitting the target (which linear menus require), because you can move in any direction into a big slice without looking at the screen (while parking the cursor in a little rectangle requires visual feedback), and you can learn to use them with muscle memory, with quick “mouse ahead” gestures.

[...]

>Swiping gestures are essentially like invisible pie menus, but actual pie menus have the advantage of being “Self Revealing” [5] because they have a way to prompt and show you what the possible gestures are, and give you feedback as you make the selection.

>They also provide the ability of “Reselection” [6], which means you as you’re making a gesture, you can change it in-flight, and browse around to any of the items, in case you need to correct a mistake or change your mind, or just want to preview the effect or see the description of each item as you browse around the menu.

>Compared to typical gesture recognition systems, like Palm’s graffiti for example, you can think of the gesture space of all possible gestures between touching the screen, moving around through any possible path, then releasing: most gestures are invalid syntax errors, and they only recognizes well formed gestures.

>There is no way to correct or abort a gesture once you start making it (other than scribbling, but that might be recognized as another undesired gesture!). Ideally each gesture should be as far away as possible from all other gestures in gesture space, to minimize the possibility of errors, but in practice they tend to be clumped (so “2” and “Z” are easily confused, while many other possible gestures are unused and wasted).

>But with pie menus, only the direction between the touch and the release matter, not the path. All gestures are valid and distinct: there are no possible syntax errors, so none of gesture space is wasted. There’s a simple intuitive mapping of direction to selection that the user can understand (unlike the mysterious fuzzy black box of a handwriting recognizer), that gives you the ability to refine your selection by moving out further (to get more leverage), return to the center to cancel, move around to correct and change the selection.

>Pie menus also support “Rehearsal” [7] — the way a novice uses them is actually practice for the way an expert uses them, so they have a smooth learning curve. Contrast this with keyboard shortcuts for linear menus: you pull down a linear menu with the mouse to learn the keyboard shortcuts, but using the keyboard shortcuts is a totally different action, so it’s not rehearsal.

>Pie menu users tend to learn them in three stages: 1) novice pops up an unfamiliar menu, looks at all the items, moves in the direction of the desired item, and selects it. 2) intermediate remembers the direction of the item they want, pop up the menu and moves in that direction without hesitating (mousing ahead but not selecting), looks at the screen to make sure the desired item is selected, then clicks to select the item. 3) expert knows which direction the item they want is, and has confidence that they can reliably select it, so they just flick in the appropriate direction without even looking at the screen.

https://web.archive.org/web/20150506123310/http://uxmag.com/...

>Self-revealing gestures are a philosophy for design of gestural interfaces that posits that the only way to see a behavior in your users is to induce it (afford it, for the Gibsonians among us). Users are presented with an interface to which their response is gestural input. This approach contradicts some designers’ apparent assumption that a gesture is some kind of “shortcut” that is performed in some ephemeral layer hovering above the user interface. In reality, a successful development of a gestural system requires the development of a gestural user interface. Objects are shown on the screen to which the user reacts, instead of somehow intuiting their performance. The trick, of course, is to not overload the user with UI “chrome” that overly complicates the UI, but rather to afford as many suitable gestures as possible with a minimum of extra on-screen graphics. To the user, she is simply operating your UI, when in reality, she is learning a gesture language.