Learning curve variations based on UI system interface
While introducing Omarchy linux distribution to a friend, I compared its learning curve to that of vi/vim. That led to an exploration of the impact that the interface of a system and the frequency of usage/practice have on the learning curve. The vi and Omarchy interfaces are what I would categorize as recall-based system, whereas Microsoft Word and Windows would be more recognition based.
Learning retention
In a recall-based system, the learning goes away, at least partially, if the memory is not exercised at regular intervals. The interval time is also dependent on the person, as it is a function of their memory. If it is not exercised at a frequency that is suitable for that person, every session starts to feel like an initial session, and one can be stuck in that zone for a long time without any reward or payoff.
Efficiency
The other aspect is that of efficiency. In a recall-based system, if the exercise is done at the required interval, then the learning automatically gets transferred into procedural memory. This has a surprisingly large effect on efficiency. Tasks can be performed much faster when using procedural memory. This is why we have so many vi/vim advocates; no other system would let them fly through the text edit operations like vi does.
Can recognition-based interface be efficient?
One could argue that recognition-based systems can also be exercised enough to get into procedural memory, and that is true. There are so many desk jobs where the same set of operations need to be performed multiple times a day, and you can find professionals who learned them by recognizing the different parts of the interface but now just go by memory; for example, at checkout counters in big stores.
However, a prerequisite is that the interface doesn't prevent the transition to using procedural memory. The UI trends in the last decade have been the worst culprits in this case; if the next page/button doesn't show up within a few milliseconds of the previous action, it breaks the flow when using procedural memory. Similarly, if an interface keeps getting redesigned every few months(blame quarterly KPIs), it flushes all the learning from the procedural memory.
Different kinds of recognition-based interfaces
Recognition-based interfaces should also be differentiated based on whether they encourage recognition only through text, visual cues or both. Devices that have smaller screen real estate have traded textual signs for icons. A person who doesn't recognize shapes as well as text might keep getting lost in such interfaces. My observation has been that kids have great shape recognition and that adults start to lose that ability as they age. Teaching people in my parents' generation to perform a multi-step procedure in the WhatsApp app keeps reminding me of this problem.
How recall based system should be learned
A recall-based system is best learned by immersing oneself fully into it. I was able to get good at vi only when I forced myself to use it as my only text editor for a week and had a cheat sheet handy to look up the key combinations for the operation required.
The command palette deserves a special mention, as it is one technique where the need for both recall and recognition is drastically reduced. There is no recognition required, and the only thing you need to recall is a keyword that exists in the operations name.
Conclusion
Thinking about interfaces in terms of recall, recognition, and procedural memory also changes how a developer should think about designing them. The right interface is not universally the one that is easiest to discover or the one that is fastest for an expert; it depends on who the users are, how often they will use the system, and what kind of learning the system expects from them. There are also many useful hybrids between these extremes, with command palettes being one example. As more software is created with the help of AI, these choices may increasingly become part of what we mean by design taste: not just how an interface looks or what features it exposes, but what kind of memory, practice, and interaction pattern it asks of its users.