Someone who's not a programer, but has learned lots of smart and efficient ways to getting their computer work done over the years. Shortcuts (keyboard or otherwise), click-hold-cmd-tab-drop or similar patterns, tags/labels for deep file organization, etc.
It seems like there's now a much wider gap between the smartphone tap-only user and the Vim/Terminal ubergeek with almost nothing in between.
I remember being floored by bureau in the 90s that completely automated their Photoshop and QuarkXPress workflow with AppleScript just by hitting the record button (not a single line of code written), folder actions, smart file placement and similar tricks.
AutoCAD had a command line. You could pick commands from the menu, or type them directly. You could make shortcuts for the commands. From there it was a short jump to stringing together several typed commands into a short script. There was a built-in scripting language (AutoLisp, a lisp dialect). The command line was also a repl, so you could type snippets of code and execute them on your drawing and see the effects immediately, making it easy to experiment.
Revit has none of this. Everything is menu driven. There is a macro system, but you have to go hunting for it. There's also a way to build add-ons and extensions by downloading an SDK and learning C++ or C#, but that's not really the same as making a quick script to automate some repetitive task. There's no command line. Even the newer versions of AutoCAD hide the command line in the default configuration. If you don't know to go looking for it, you'll never find it.
In order to be able to type a house you need to know the multiples of 12 and 16 up to about 30 or 50 x 12.
I only learned now that emacs could do it.
For anyone else who didn't know, try ":help undo-branches" or take a look at https://vim.fandom.com/wiki/Using_undo_branches , which has a simple example of use.
This is one thing it does very well, it beats emacs hands down in history visualization (at least without undo-tree, I've never tried it).
- you can test the rendering layer in isolation by using the GUI to display two pieces of information manipulated by the CLI and comparing the renders, eg blank screen -> add some object.
- you can comparison test the GUI, eg pressing button X produces the same result as CLI option Y.
Properly testing a GUI requires having an internal CLI, in places I’ve worked — eg, app companies.
It doesn't matter if it is GUI or terminal interface, software must be _humane_, forgive mistakes and provide a way out. As much as love Unix coreutils and have them in may fingertips, those are the least humane programs I have ever used.
Surprisingly, git seems quite humane, even when you screw things up it gives you a lot of safety mechanisms to recover.
You have to earn it. I admit that when I started using git sometimes I made a copy of the repo just in case I ended in a state that made it easier to nuke it and start again
There's also a psychological element to it. If you can verify for yourself that the repo can't possibly contain anything that would mess you up after an earlier mistake, it's much easier to do things than if you have to worry about using the wrong branch name when you don't know how to delete branches, for example.
I use a Mac for work, and one of the first things I did was to alias `rm` to the utility `trash` -- instead of immediately marking the bytes as free like `rm` does, it'll move the file(s) to the system's trash can.
The problem is that filesystems don't get enough love. There are plenty of more fundamental problems that aren't going anywhere, so do not expect this to change.
The productivity industry is huge. Pop into the YouTube rabbit hole of people demonstrating how to use tools to be more productive, and you’ll stumble into a community that is bending every tool to basically serve their personal approach to life. The effectiveness of that is debatable but these are people who are absolutely pushing apps to their edge. A lot of them are mobile tap-only people too. But they also satisfy the condition of learning lots of smart and efficient ways of using their tools.
Content creators. Especially younger ones. I’m floored by the kinds of videos younger people, aged 16-23, are making by pushing the limits of their mobile devices to create engaging content. And I’m not even talking about the ones who make use of multiple tools across both laptops and smart phones. I’m just thinking of the people who will combine a few apps with the native functionality of something like TikTok and they create high effort content that is representative of someone who has taken the time to learn smart and efficient ways to get their work done. Again, the value of the output can be debated all day. But I think it’s obvious how far people are pushing their tool sets.
There are probably other groups I don’t know of because of my bubble, but I do think the above groups show that power users are alive and well even if they look different than they did in the past.
Given solid UI design, the security tradeoff is probably worth it if the two are actually connected.
On the other hand, those same people had folders on their desktops and managed files reasonably well. And now that even got a bit more confusing on the desktop, especially with MS/Apple insistence in selecting One/iCloud drive by default.
No install script, no pkg files, no hidden prefs, nothing.
Want to uninstall it? Drag it to trash.
It was only when Apple started to be affected by mac piracy that they started down the road of restricting everything and when they started making real money selling their own content on their own platform (music then movies through iTunes) they hit the friggin gas.
Default macOS will still check for Apple’s seal of approval on software, but this is done by developers signing their distributed app.
Some apps, like Wireguard, can't even be installed outside of the App Store, because Apple won't sign the entitlements they need to run outside of it.
Where do you get the app from? Is it safe?
App Stores solve all this issues while, unfortunately, making some really useful apps almost impossible to exist.
It’s like shipping entry level jobs to other countries: People lose the ability to learn and grow on the job. They lose the ability to work their way up. Instead you have to rely on an establishment that is hands-off.
It’s “study learning” vs actually doing the work.
With power comes great responsibility; I'm confident it was a tradeoff, because for every one competent and savvy user, there were ten that would have to call IT every week with yet another virus or breakdown.
That said, where I work there is a special path to admin if you have an actual need for it. It requires a security training course and special approval from a supervisor and the whoever leads technology in your division. And also signing a disclaimer that you now take full responsibility for any & all things that might possibly go wrong with your system due to use of admin privileges and all the consequences that entails, including "disciplinary actions" (screw up bad and you'll get fired). Makes one a bit more paranoid about security, which is healthy. I just wish the training & approval process included the education & tools needed to spin up your own VM's. It's not hard and the tools are free and (for anyone who really needs admin) relatively user friendly.
Otherwise things are very locked down. IT would much rather have you reboot than grant access to taskmanager to kill your own user processes.
There is no room for power users in that market, only passive consumers. Besides, power users might be motivated to circumvent their systems and do things that companies can't extract rent on.
Because their old system didn't work. They were forced to always bolt on new features and redesigns, whether they added value or not. And there were plenty of people who never upgraded, because what they had worked just fine.
My colleagues in the sciences are, not surprisingly, even more computer savvy, though I don't know how many do actual programming.
Five years ago, there was a literature professor in my department who didn't even use a computer and had to be contacted by telephone, fax, or—gasp—a handwritten note slipped under his office door, but he has since retired.
I believe they are mostly ignored.
A power user is a user, who doesn't fear the technical outcall. (S)he wants to get work done and uses a computer as a serious, professional tool. Sooner or later this will require this kind of user to step into configuration, the command line, etc. These users will accumulate IT knowledge auto-didactically, by visiting forums, mailing-lists, etc.
However, they come from many different positions and professions. And as such, they are a moving target of many, often highly specialized, communities. Not the typical customer base a large corporation wants. The large corporation will delegate such communities to "consultants", which those communities either can, or can not afford. I am not an archaeologist, but I could imagine, that archaeologists may benefit from tablets, that can do photos on-site and a document format, that let's them keep track of their excavations, link those to relevant data, etc. Photos like this  clearly show a pattern, that relies on coordinates. However, I guess, they are notoriously underfunded and nobody cares anyway.
> Software (and online services) has been in a race to the bottom for over a decade.
I wholeheartedly agree.
I remember the times of ActiveScripting on Windows. It was a great (and much needed) idea, that, however, has been positioned at system admins only (the most typical power user in a Windows environment, typically just some secretary or coworker, who is ready to do it, than a full position) and thus never really took off. Same for XML. Just because software-engineers don't like the format, it must not mean, that there is not some people being "document-engineers". Not everybody, who wants to use a computer programmatically, works at a Web/Cloud startup, etc.
They might all hate the tool, but are able to navigate between entering and editing copy, editing layouts and running orders, searching wires then adapting it into stories etc. with great speed with shortcuts, saved workflows and yes, awkward cludges like always-open text files of boolean searches they frequently re-use.
The minute they need to leave their tool to do a peripheral task though, all of those gains are lost. The new web-based video subtitling tool might be better than their old workflow and something they use several times a week but there's an instant assumption that it's a mouse-only task, even if the tool is a11y-aware enough to not be. Lots of "oh is it ready? Ok now I...think I click this bit" because things like communicating status and progress aren't consistent or ubiquitous. It just doesn't have the efficiencies of their ugly old thing.
On the one hand they could learn how they could automate their browser to actually integrate these tools with their workflows better, but nothing about the browser environment seems to give the impression to this class of user that it can be used in this way.
I don't know if that's just about tools that each have their own look and feel, or that the browser metaphor is too overloaded (because that feels like a very 2003-era concern :p)
It seems like once they get a few years under their belt they move into Product or Project Management or gain sufficient scripting experience that they move into an entry level Software role.
There use to be a terminal app (DOS) at a company I worked at which only worked with shortcuts, the learning curve was pretty steep but after a while using it you could be pretty efficient.
Now they replaced it with a nice UI but you don't have shortcuts. Maybe there wasn't enough demand for it.
In programming we mostly use tools we also use at home or elsewhere, so the learning cost is worth it (if I learn VIM, I will be more efficient at every programming job in the future, not just this one)
I don't think that they are disappearing; life will find a way. Although, I do think that the median software is becoming harder to automate or stitch together (at least for someone without existing scripting knowledge). Tools that do have APIs don't offer a nice, smooth gradient from beginner to "power-user" that anyone could find themself pulled up.
An exception to this is Excel, which I believe exposes this "gradient" rather well.
Take something like Tableau for instance. If you visit the Tableau forums, there's some really creative people who are constantly coming up with solutions for dashboard problems, anything from rewriting a SQL query to workarounds with Excel, just to get a dashboard to display the right way. Some of these solutions involve a deep understanding of how to manipulate data (windowing functions, pivots, date arithmetic etc.).
And at most big companies, you'll find Excel wizards who do wonderful (but cryptic) things with VBA macros. You'll find full mathematical models embedded as Excel VBA macros. Maintainability aside, you can do some pretty mind-bending things with VBA.
There are also the AutoHotkey users who automate GUI tasks by recording mouse/keystrokes and then tweaking them. We had more than a few of those in my last company (bigcorp).
If you look outside of the consumer macOS ecosystem, you'll find that power users are alive and well.
Interesting you say that in a comment thread about an article that mentions several times how macOS and a couple bits of software designed for it helped popularise the command palette (which is a power user-friendly tool). Apple’s OSes have always have advanced features for power users, from the Apple Script of all to Automator and Shortcuts, and all the places where Spotlight is used. MacOS is for noobs is quite far from the truth. Sure, it can be used by noobs, but it does not mean it is restricted to them.
I do think that despite macOS having these power user tools, their uptake in modern times seems more limited compared to the olden times (System 7-9) and when compared to other platforms. I know I was excited when Automator came out in OS X Tiger but I don’t know anyone who’s really used it outside of folks who publish their workflows.
If MS would add something like VS Code's command palette to Word, it would blow Latex outta the water. I've tried Latex (in VS Code) and I was able to write my own snippets using Regex and "prettify" the code. I miss those things in Word.
Plus, Word must have something like settings.json where I can see the list of all custom shortcuts that I've set. And I also wish Word Find would use the typical Regex to find things in text.
I never thought one day I like Word, but this software has been a life saver (can't say that so much about PowerPoint and the rest of the office suite though).
Powerpoint is often abused but it works well, and if you learn the shortcut keys for moving objects around it's actually very capable for making sketches and diagrams. Much easier to make a poster in powerpoint than word, actually because each slide is strictly one page and you don't have to fight margins.
But even the base level UI is not on par with basic desktop usage. There's no system wide Undo, no Select All, no standard menu…
I would say that we're continuing to move away from interfacing with computers as humans (with near natural language scripting, power TUI/UIs etc...) - to interfacing with computer as computers (writing code, digesting APIs etc....).
I'm not saying it's a bad thing - but it's certainly something I've noticed and it does seem to cause a lot of NIH and reinventing the wheel.
Never ascribe to malice... Having sat on the product side before with some of my clients, I can describe it from their point of view. Power users typically consume a disproportionate share of support engineering and development engineering hours per account compared to their normal user calls from an accounting perspective. The holistic, value-adding way to approach this is to work more closely with the individual power users to find out what they are doing in detail for each of their industries, find commonalities, and push product capabilities in those directions.
The reflexive accounting response is invariably "make the power users stop using support services so much". Engineering then gets asked, "how do we stop these kinds of questions?", and the holistic response is shut down because "that costs too much, I want another option". You can see where this is leading...the features power users leverage get sunset, and finance/accounting is happy when they become responsible for a KPI improvement.
...while ignoring that any of them would give their eye teeth for the kind of profit lock-in Excel delivers, and under their KPI regime, Excel power users would have been stillborn.
Never ascribe to malice, that which is adequately explained by incentive structuring.
BTW, I usually clarify with leadership what they envision in these situations in a behind-closed-doors meeting that doesn't challenge them. Most of them honestly do not want Excel-like lock-in via power users. They feel it is too fraught a road and that they can achieve lock-in in other ways. Fair enough, and my due diligence advising them is discharged (I might not agree, but there comes a time to help the organization put all its wood behind a single arrow).
Incentives sounds exactly like what the person you're responding to described. Malice, on the other hand, doesn't show up at all in what they wrote.
It seems weird to introduce some element to the discussion yourself, and then work so hard to explain why an explanation that depends on that element is the wrong answer. It amounts to a sort of elaborate and roundabout strawman.
We're not disappearing, per se, just being utterly ignored. Mass market is moving towards methods of turning all computing into a phone, with vendor lock in and the user as nothing but a consumer who needs to pay to do things with their own devices.
I am unprofitable as I do not need to pay for an app/macro/SAAS to do things but also don't do those things as a business and therefore will not be paying to outsource the costs of doing those things.
In truth, I am in this area in many areas, from computing to kitchen appliances and grills. It feels that global capitalism is highly antagonistic to products and services that empower users to do things themselves.
I'm always writing one-off scripts to get a repetitive job done.
Either you learn 490 tools, methodologies, framework, libraries and become a developer or push button on apps.
The distance between the two extremes is increasing and the middle ground is disappearing.
What gives you this impression? I thought different software at art university (Unity game engine, Blender) during the last years. The spread between people who alt tab their way between programs and people who move the mouse as if it was some foreign object didn't change much since 15 years ago in my experience.
What might have changed is that people have different expectations in how easy/hard software should be to learn.
- there are more formal solutions available. I don’t need a macro for automated responses because Freshdesk does that for me.
- culture has moved toward seeing apps as smaller on average (except for MSFT) and not extensible. I think our attitudes toward mobile have had a big effect.
- a lot of people get as much utility as they expect out of their machines unmodified.
This is sad because terminals are powerful tools that are fast, composable, and programmable.
What we need is for terminals to provide easier hooks to help people become "vim/terminal ubergeeks". Use a command repeatedly? Help the user set up their first alias. Need to use an advanced sed command? Help the user form their first sed and then slowly take off the training wheels. Programmers really do want to learn to become power users. Terminal UI needs to evolve to help them.
Smartphones are truly impressive tech devices. There are people around the globe running businesses/houses/hobbies with nothing but a smartphone. On the other hand, “code” has never been more accessible and powerful.
I feel like the disappearance of the “power user” is not like this of the middle class in our western society. Maybe they turned into “power doers”.
Almost genocide of.
I put this squarely on Apple.
They have continually sucked people in with promises then shut the door behind them, replacing those promises with restrictions and entrenching in to “the one true ecosystem”
I thought a lot about this line:
> you had the best of the terminal paired with the best of graphical interfaces
Maybe there are many parts of a terminal that are “the best” for different people or use cases, but to me the key feature of the terminal is the ability to compose, extend, and abstract. Use a command with certain options a lot? Turn it into an alias or one-liner script. Use a pattern of commands a lot? Turn it into a script. Use a particular command really a lot? Add it as a custom keybinding. And it's pretty easy -- once you've paid the price of learning to use the shell at all, you are ready to start writing basic scripts. Granted, the price of entry to learn the shell is high compared to command palettes. But there is so much there that command palettes are still missing.
macOS has a similar feature for the menu bar- every app has a Help item that allows you to search all menus at the same time. It doesn't work as well as a command pallet but it is incredibly useful for menu-heavy apps.
Keyboard shortcuts are fast but they require memorization. They're great for something you do many times a day.
Command pallets fit in the middle. They're most perfect for the niche where you use the command often enough to remember that it exists and at least roughly know the name, but nowhere near often enough to warrant memorizing a keyboard shortcut. Especially for text editors where you're already in typing position, they're much faster than menus and not that much slower than shortcuts, and you can give access to much more commands than you can define reasonable shortcuts for.
And as you said, CLI with the precise syntax requirements is simply the worst.
Things DID improve, e.g. tab-autocomplete evolved very well. But that's not enough, and editor's command palettes show that. I actually thought I'll give some more quick examples than discoverability, but then I realized that you could fill a whole document with them...
- murex https://murex.rocks
- elvish https://elv.sh
Hi, author of _murex_ here. I don't believe that to be true. I mean, I do agree that it would be great to replace the 50 years of legacy of TTYs, byte streams, in-lined control sequences (eg ANSI escape sequences), etc but you can still achieve what you're after. And murex does aim to do this because it is as much inspired by IDEs as it is by scripting languages.
To give an example of these feature:
+ Murex does "fuzzy" search against all possible completions (so does Bash et al with addons, but murex does it out of the box). Do this by pressing ctrl+f
+ Murex does in-line spell checking
+ Murex supports typed pipelines (inc complex formats like JSON, YAML and CSV) and will autocomplete commands that support that data type by default. But it will also work seamlessly with existing POSIX / CLI tools too. It does this by passing the type information in a separate channel to the byte stream. So POSIX pipes work the same but processes that support murex can do richer things with the pipes
+ in expansion of the above, structured data is handled intelligently within murex. eg if doing a regex match against a JSON array you don't need to escape out the JSON formatting. Your tools will automatically only work against the values inside the array. And you can use the same commands against JSON, YAML, TOML, CSV, C-Expressions and others -- the commands understand what the file format is and natively adapt to it. Meaning you don't need to learn different tools for working with JSON than you would for CSV, YAML nor any other format.
+ Murex will display descriptions against each command suggestion (Fish does this too)
+ Murex parses man pages to help build up autocompletions if no autocompletion are defined (Fish also does this)
+ If you're running tmux, you can press F1 against any command in murex and it will open a pane alongside your interactive terminal with the man page (if an external command), a cheat sheet, or the code (if a murex function) so you don't have to remove yourself from the terminal to double check a commands usage
+ Murex has a hint line that acts like a status bar. In there you'll see descriptions of each command (also parsed from man pages if external executable) and also details about the type of command (alias, function, external executable), where is sits in your file system (even showing the path of symlinks) -- so you know exactly what command you're calling and what it is supposed to do.
+ syntax highlighting (this is an increasingly common feature in shells these days)
+ syntax completion (eg quotation marks will smart close)
+ multiline pipelines are handled much better (eg you can up array to the line above and murex wouldn't erase the current pipeline to show the previous one)
+ smarter support for pasting multiple lines (murex will detect if you're pasting multiple lines and allow you to preview it before it then runs those lines. Saving potential mistakes where you're pasting the wrong thing from clipboard)
+ murex can in-line images. It supports client specific ANSI escape sequences for iTerm2's, Kitty, Terminology (Enlightenment) as well as Sixel and ANSI blocks; and will auto-detect what mode will work best with your terminal emulator.
+ colours errors in red (inc STDERR)
+ displays stack traces of errors (inc STDERR)
These features are configurable (can be turned off if you wish) too so if any one of them is not to your tastes you can change the default behaviour.
To be clear, it is still beta software but I've been using it as my primary shell for ~5 years and there are other shells that exist that support some of the same feature sets too. So there definitely are other shells out there that are striving to achieve what you're after, and I'd like to think are having some success at it too.
changes to tools:
- output less noise that drowns the signal. The toolchain used to build a program from source is particularly problematic here.
- if the output has to be huge, make it structured / collapsible
- output messages that are both human-readable (so humans don't have to read cryptic data that is meant for the computer) and computer-readable (so the computer does not have to parse human-readable messages, which is fragile). Yes, that's hard.
- Provides tools that each solves one problem, and solves it well.
Some things that could have been changes to tools are implemented by tool-specific extensions (IIRC, bash autocomplete of tool parameters works like this). Discoverability can to some extent be implemented like that, including inconsistent naming of command-line options for different tools.
Might require changes to the kernel (details depend on the OS, and on whether the terminal runs inside a GUI window):
- proper handling of color. Right now, color is encoded as in-band information (ANSI escape sequences) that confuse various tools, e.g. grep cannot find a substring if there is a color change in the middle of a substring. The workaround is to have all tools detect if they write to the terminal or a pipe and not output color at all, which means that I can't grep without losing color. This might require changing the kernel because the terminal driver that defines how color is encoded sits there (again, might be different in a terminal window in the GUI).
I'm having much fun scripting in the Fish language at the moment, and using the shell in interactive programs.
See here for some usages: https://github.com/junegunn/fzf/wiki/Related-projects
Currently, we're currently building a feature called "Tasks Not Commands".that allows users to interact with the terminal via a task instead of an obtuse command or series of commands. See the mock here . For example, be able to type "undo last git commit" instead of needing to memorize `git reset --hard SOFT`. We envision users being able to create and share their own custom tasks as well. What do you think? Join our discord to stay updated. 
You can't do this on Mac? Why? I found this really jarring. I know on Mac you can press CTRL + F2 (add Fn key if you have one) to change the keyboard focus to the menus but it doesn't underline the letters that will work and you have to hit enter to open things so it's clunky.
The command palette is nice for discovery of lesser used commands and when there's lots of them but it's less predictable what keys you need to press to fuzzy search to the command you know is there and it doesn't teach your fingers the shortest key combo to trigger it.
However in MacOS `command-shift-/` (⌘?) immediately shifts focuses to the help menu where you can begin typing to navigate directly to any command that appears in an application's menus, without needing to know where the command is hierarchically organized. It's very fast, and seems to work everywhere.
I have Karabiner-Elements configured to register ⌘? whenever I press and release the left control alone without using it as a modifier of any other key. The `to_if_alone` condition in Karabiner-Elements is one of my favorite ways to re-use all of the modifier keys to invoke special commands. It would be great if I could figure out how to do that in Windows.
The solution was in the switch to Ribbons: the underlines were replaced with keytips that are displayed when you hit Alt and as such aren’t required to be a character in the command’s name.
Here's how it struck me like a freight train: I was looking at some instructions for installing certain "drivers" for some technical hardware. The instructions for Windows computers was a series of color glossy screen shots, with circles and arrows, and a paragraph under each one. Of course they were particularly hard to follow because they hadn't been updated to the last revision of the OS.
In contrast, the Linux instructions were:
sudo apt install foo bar blah ...
sudo add a line to this file ...
Press Windows-R+cmd, enter these commands
Of course it was a little harder (but not that much) to master the tools of this era but once you understood the basic paradigms (files, folders, windows, menus, toolbars, common discoverability, common keyboard shortcuts, F1 for help…) you could become proficient in any unknown software way more faster than today.
Now, there is nearly no transferable knowledge between 2 softwares. For me this looks like « knowledge lock-in » (which adds to the vendor and data lock-in, btw).
Well, we still have Linux if we want to learn something useful. But even there if you use it professionally, you’re probably going to be stuck with all those « I’m unique » Electron apps.
tbf, I think what we are missing is a truly high quality multi platform GUI toolkit able to work with modern language. Most are still only officially supporting C++ and nobody wants to write a complex application in C++ anymore.
Command line is efficient and good for applications and function that you use on a regular basis, but can be difficult with apps that you are new to or only use occasionally.
A proper UI should be able to accommodate both the efficiency of familiarity and the discoverability for a novice.
IntelliJ has a command palette too (Ctrl-Shift-a), but it’s horribly slow and has many items with the same name doing different things (try looking for “settings” for example). But it does allow you to add a shortcut to a command you find on the fly, which is great.
Then I thought "...assuming it isn't already built in somewhere."
Looks like it's `apropos-documentation`: https://www.gnu.org/software/emacs/manual/html_node/emacs/Ap...
Can't be too hard to hook that up to one of the auto-complete M-x replacements.
Someday I'll read that while manual.
Anyway, M-x-helm is pretty critical to my workflow; half forgotten (or guessed) commands work pretty dang well when you can complete them.
He’s got a bunch of other really nice lightweight packages that leverage built-in completion mechanisms. See also https://github.com/minad/vertico#complementary-packages
For code, company mode is probably what you want. For the minibuffer, Ido (or fido if you want super-vanilla) plus which-key will get you far.
Here's what I have in my init.el:
(setq ido-enable-flex-matching t)
(setq ido-everywhere t) ; Also work with C-x C-f
> The convention of being able to search Settings menus feels like one of the only things that's got unambiguously Better about software UX in about a decade.
Can't find any evidence of it, but I can find a 2003 Guido van Rossum review of Jeff Raskin's book "The Humane Interface" in which Raskin mentions LEAP(r) a design for adding search-backwards and search-forwards keys below the spacebar to save people from arrow keys and mouse use, which is demonstrated on the CanonCat computer from 1987 in this video on YouTube.
LEAP was Emacs incremental-search, but on the Cat the idea was to use it to replace all cursor movement except "creep" left and right arrows.
Thanks for the video! I had never seen it. YT suggested https://m.youtube.com/watch?v=jErqdRE5zpQ, another Cat video. https://m.youtube.com/watch?v=XZomNp9TyPY shows a brief clip of the Forth interpreter.
- Jef Raskin
Admittedly, these are non-techy folks. But they are daily Mac users. It's weird, like the OS discourages curiosity and experimentation.
And then there are those times when I stupidly assume things, like how it will surely be trivial to remote desktop from my laptop into a Mac while someone else is logged into a different account on the Mac. What a shit-show. My reaction: "are you f*cking kidding with how horrendous this is?" Mac owner: shrug.
Bah. Now I'm just getting narky. Rant over :)
The system-wide shortcuts are a bit less discoverable but, they’re there if you know where to look: either search “keyboard shortcuts” in the os help system or go to system preferences > keyboard > shortcuts.
I'm not exactly a Windows fan, but (generally speaking) in a standard windowed program, just hitting alt focuses the menu. Windows is almost entirely navigable by keyboard by default, without a mouse. It's much more discoverable and efficient.... although that's been tanking since Win 95 :)
Also, if I use the Finder help menu to search "keyboard shortcuts", it gives me a local help article "Use macOS keyboard shortcuts". This article talks about a bunch of ways to find keyboard shortcuts and also links to this knowledge base article: https://support.apple.com/en-us/HT201236 (This is actually a sort of step backwards, from when I did exactly this around '07: at that point, the Mac Help system actually listed a bunch of handy keyboard shortcuts and didn't rely on online resources for them).
But of course the shortcut to jump to the search area is completely undiscoverable, as are many macOS features. You can see it if you go to preferences -> keyboard -> shortcuts -> app shortcuts. (And you can also reconfigure the shortcut key, or reconfigure any shortcut in any app. That feature I love)
I have yet to find a similar functionality from any other OS.
At one point I had a newish version of OS X spotlight pared down to be about as functional as the Windows 7 start menu Search. If I had wanted command-space to be closer in feature parity to a Windows 10 start menu, it's approximately five reasonably intuitive mouse clicks to get to the settings prefpane with those checkboxes. I too have yet to find similarly well made functionality from any other major-ish desktop OS.
I love Alfreds custom workflows. Half the time I’m using it the same way I’d use Spotlight, but I’m also using it to trigger custom workflows constantly. (Which often just call out to CLI utils or run zsh/Apple/Swift scripts, integrations that Alfred makes easy)
I also appreciate its global hot key support. For example, I’ve setup the F14/F15 keys to adjust brightness on an external monitor. (Just by having a workflow call out to `ddctl`)
I couldn't go back now, TBH, without using some kind of Mac OS native scripting components.
However, you can bind it to any shortcut, so binding it to Cmd+P would give you a command palette in any app (and then you can exclude e.g. Sublime Text/Merge who already have their own palettes).
I've tried it, but it doesn't work in most of the apps I use like LibreOffice, Firefox, Double Commander.
Quicksilver was so far ahead of it’s time that I would say that Spotlight, Alfred, Mac’s Help search, and a whole boatload of Windows/Linux apps were a direct result of it.
If you get an opportunity, run an early version coded by Merlin in an old version of OSX
I've been using it regularly since around 2002 and this functionality has always been core to its being. It makes discoverability hugely simple, just start typing what I want to do.
I've always wondered why more tools haven't had similar functionality. I'm glad to see the growing population of command palletes some 20 years later.
People keep on telling me how amazing Blender or SketchUp is, and they just can't understand that the perfect 3D modeling program with the perfect UI already exists, and has existed for over 20 years now.
P.S. Super annoying how the website intercepts my Ctrl+F.
well, for what it's worth, many modern apps aren't following that guideline. for a long time i have questioned the disappearance of tooltips in user interfaces. especially when everybody seems to come up with their own iconography nowadays.
the answer i got from UX people is that "you can't hover or have tooltips on mobile". they are trying to achieve uniformity between mobile and desktop.
they will probably confine that useful command palette to particular apps too. because you can't have a command palette on mobile either.
Achieving uniformity by reducing the user experience to the platforms' lowest common denominator. Not the best solution!
Right, so don't do that. But, desktop and mobile are different platforms with different input devices, and designers should make use of both to create the best experience for users. There are certainly tradeoffs in terms of cost to implement versus value for users, and if the argument is "it will simply cost us too much money to implement tooltips" then I suppose that's up to the product manager or equivalent. But, "we can't have tooltips on desktop because the mobile version doesn't support them" is a non sequitor. If a UX person gave that as a reason, I'd have some questions for them.
I actually agree with you that this type of deep customisation is great for a "productivity tool" like VS Code.
For something that people don't spend hours of every day in, though (say, a weather app), you don't need or want this level of customisation.
Though I was actually thinking of SketchUp when writing that. VS Code does not provide always-visible labels for icons (tooltip only), though it’s something we’ve discussed and I’m in favor of. I believe Teams recently adopted them.
But really any supposed psychological phenomenon should be looked at skeptically absent overwhelming evidence like IQ or the Big 5 personality traits. Here are three links on "choice overload":
https://www.researchgate.net/publication/48210291_Can_There_... 2010 meta-analysis, "we found a mean effect size of virtually zero but considerable variance between studies"
https://ieeexplore.ieee.org/document/8426193 2018, "...where they could compare them one another anytime with relatively low cognitive load, the choice overload did not occur (Experiment 1). ... where participants had to compare them based on memory representations with relatively high cognitive load, the choice overload did occur (Experiment 2). These results suggest that the choice overload is actually replicable when cognitive load is sufficiently boosted."
http://psychbrief.com/choice-paradox/ Nice overview of some actual studies and the underlying experiments, as well as common flaws in the mathematical methods used for analysis that apply to many psychology studies.
I would like to see someone try the opposite, where when possible gaps in functionality on one platform or form factor are filled in, so all users’ experiences are elevated by the most capable target rather than dragged down by the least capable. That will probably never happen though.
Yes you can. The generally agreed upon way to do this is by long pressing whatever you want to see a tooltip over.
You can stop showing that line of text once they've shown a tooltip (or two, if you're worried about them triggering it accidentally and not knowing how they did it).
I think long-pressing for more info on touch screens feels quite intuitive, similar to how hovering feels intuitive when you have a mouse pointer.
I feel like this is some fundamental UX dimension here. Cost and risk of learning. How much time do I have to use to learn all the commands or find the right command and if I have to try it what is the risk of breaking something?
Just as relevant in cli applications.
> The iPhone 11 and iPhone 11 Pro will ditch 3D Touch in favor of "Haptic Touch," according to Apple's website. ... The new iPhones' Haptic Touch will be responsive to how long users hold down, but not the force of the tap.
I would love that feature, but I think it has to be very integrated into the software and the APIs of the phone OS or no one will actually use it.
I avoid using VS Code for this reason.
If I type three characters and press enter, it shouldn't matter if I wait 0.5 or 1.8 seconds before I press enter. But with this mechanic, it typically does. What is "set _rem_inder" one time is "_rem_ove all files" the next time.
Everyone has their own preferences; personally, every time I open Word, I am confused and disoriented and have no idea where to look for what I want. I think it's best for no-one to try to impose their UI preference on everyone, and for all of us just to use the software with which we find it easiest to interact.
AutoCAD strikes me as a fundamentally different paradigm in that its command interface is "always active" so to speak, whereas menus/toolbars feel mostly like an optional overlay, at least to an experienced user.
Although AutoCAD is my preferred tool when drafting electrical architectures and wiring diagrams, the mouse as primary human interface is simply unavoidable in any sensible CAD, which makes constantly having to release the mouse to type the next command, or F3/F9 to toggle object/grid snaps (especially with shit modern keyboards without standard F-key separation e.g. MX Keys) admittedly annoying. I contrast this UX to SolidWorks which is overwhelmingly mouse+toolbar in a way that's comparatively trivial to navigate, or Altium which is driven by single hotkey sequencing that allows the other hand to stay fixed on mouse.
I quickly fell in love with this interface and immediately switched to using the command line for the vast majority of functions.
Some common commands can also be annoying when the required minimum characters don't cleanly map to a single hand, e.g. [E][X][P][L][Enter] to explode; or when they map to the other hand, e.g. [P][L][Enter] for polyline.
Altium's approach is literally single hotkey sequencing (i.e. no [Enter] after every command) which map directly to menus that underline each hotkey as a reminder, e.g. to [P]lace a [W]ire or [P]art in schematic capture, it's [P][W] or [P][P], respectively, while the menus change with ever key press. Yeah, your left hand is all over the keyboard, but every key press is a meaningful context switch.
Anyway, the removing of menus was not caused by the addition of command palettes. I think the history is that microsoft believed icons was easier than text, so they made the ribbons, and then for a while other removed menus in favor of ribbons, but then they realized ribbons sucks, so they removed those, and then there was nothing, maybe a hamburger menu if one of the UX's had done webdesign before.
Thanks for clarifying.
I am unsure the UX is there to help make that discoverable in a menu; you'd be so deep that it'd be behind multiple sub-nests at a minimum. Seems much better to have a flat search for this.
But menus? Nobody would need them if command palettes would have some discoverable hierarchic structure to them. That's the last missing part to make command palettes "perfect".
No need to click search bar, or look at the search result list. One only needs to memorize, or setup, a keyboard shortcut like Ctrl+Shift+M, and with muscle memory it will consistently take well under 1 second. Search UX is slower, needs more clicks or key presses.
To each their own, however I can see how it would be annoying when they don't include a menu for anything for folks who prefer that.
First thing I install on any machine I use.
Have you seen PackageControl?
Did no know this. Thanks!
In vs code, i do command pallette, in iTerm i use fzf, in mac i use spotlight, in iphone i use spotlight to find apps, in windows i press start then start typing to search..
It is true, it is the norm! It's just super convenient
It's so neat and I want that in my Quicksilver / Alfred!