helloSystem: Three-layer UX design philosophy for Simplicity and Power
One objective for helloSystem, an operating system welcoming to switchers from the Mac, is to be both easy to use for “mere mortals” yet powerful under the hood for advanced users, a combination that had been skillfully mastered in the first releases of Mac OS X (before they started to lock everything down). So the question is, can we take this objective of being easy but powerful but take it even further than Apple ever did?
Imagine you want to set the keyboard language to German. Does it really need to be any more complicated than that?
How hard can it be? I think it should be only one click in a preferences application. Yet most existing open source desktops (developed by geeks for geeks) screw this up so badly that it can actually make me angry.
Can we do better than that? Sure we can.
Here is what I call the “three-layer design philosophy”:
- For mere mortals, remove everything that is confusing
- For advanced users, give raw access to the underlying components
- For developers, show’em the code
Layer 1: Remove everything that is confusing
This layer is for “mere mortals”. It is what grandma sees when she is using the computer. In this layer, expose only what is needed to get 80% of the users to get their job done 80% of the time. Remove everything that is not essential or requires much explanation. In most cases, Layer 1 will be a graphical application (with an uppercase name, such as “Keyboard”).
Compare the left-hand side dialog (from KDE) with the right-hand side dialog (from helloSystem). Which one would you want to use if all you wanted to do was switch the keyboard language?
Layer 2: Give raw access to the underlying components
This layer is for advanced users. Mac OS X used to be great at this, but with Apple’s continued focus on iOS, Memoji and watchfaces, and with locking down everything, their current systems increasingly fall flat in this aspect. This layer is all about explaining advanced users how things work under the hood, and give them raw access to tweak things. In most cases, Layer 2 will be a command line tool (with a lowercase and often cryptic name for historic reasons, such as setxkbmap).
In helloSystem, we give access to the raw power of the underlying core operating system, FreeBSD.
Can we go even further with this concept?
For users who want to tweak settings more than what the GUI offers at first sight, we make it as easy as possible to access the right information. In this example, by linking the man page for the setxkbmap command line tool which is being used by the GUI under the hood. Arguably, using that command line tool will be more satisfying for advanced users than trying to figure out from the convoluted KDE user interfaces what things could possibly mean.
Layer 3: Show’em the code
This layer is for developers, including first-time developers. Here the beauty of an open source operating system such as helloSystem can really shine.
From my own experience, it is good to know that the source code for the applications one is using is available somewhere, in case one would ever need it.
But then, wouldn’t it be much cooler if the source code was always right there, available at your fingertips all the time?
In helloSystem, many applications can be right-clicked to reveal their source code. This is because they are written in Python, an interpreted language that effectively results in the source code to be always present.
We could extend this concept by providing a “Show Source Code” menu entry that would open a web browser pointing to the GitHub repository of compiled applications, so that, just like in the Python example, you could have a glance at the code very quickly.
Can we embrace the open source nature of helloSystem even more?
Consider this:
Would you be more likely to peek into the source code if it was presented to you in this simple way?
So here you have it. My “three-layer design philosophy”:
- For mere mortals, remove everything that is confusing
- For advanced users, give raw access to the underlying components
- For developers, show’em the code
But wait. There is one more thing.
Layer 0: Zero configuration
Now that we have looked at three layers of user interface to set the keyboard language, wouldn’t it even be much, much cooler if the user wouldn’t have to set the keyboard language at all, because when you attach a German keyboard the system just knows that it is a German keyboard and configures the system accordingly, at least for the vast majority of users? At least 80% of people with a German keyboard will want the keyboard layout to be German. So why not just do it? Using English is wrong for at least 80% of people with a German keyboard. Using German will be right for at least 80% of people. Yet most operating systems just default the keyboard language to English all the time.
Turns out that even in the days of USB, most keyboard manufacturers decided to save 2 cents in production by not having the firmware communicate the keyboard language to the system. What a pity! Luckily, some genius at the Raspberry Pi foundation finally produced a keyboard that can do the job — with the result that I have equipped all my computers with their keyboards. (Unfortunately that genius did not make any attempt to get any of this standardized, what a shame.)
helloSystem will detect the keyboard language and make intelligent guesses regarding not only the keyboard layout, but also the system language, and timezone based on this information. helloSystem will also read language information from NVRAM (also known as “Parameter RAM” or PRAM) on Apple devices, and use that information. Possibly we can also find other sources of information to make even more intelligent guesses.
The point: Zero configuration is what gives the user those pleasant “it just works” experiences without having to fiddle around.
A true master in this area is Stuart Cheshire, the mastermind behind Zeroconf networking (also known as Bonjour). Apple was kind enough to not only introduce this technology, but to also make the specifications and even code publicly available. Yet it surprises me all the time how neglected this building block for “it just works” is by many open source systems. But that will be the topic for another day.
So here we go:
- Level 0: Out of the box, make it just work without fiddling around. For example, pre-select the correct keyboard language based on hints the hardware may be giving
- Level 1: For mere mortals, remove everything that is confusing. For example, just show the most common keyboard languages in their own language and make them selectable by just one click
- Level 2: For advanced users, give raw access to the underlying components. For example, actively point power users toward the underlying command line tool and its documentation
- Level 3: For developers, show’em the code. For example, have a “Show Source Code” menu item in the Help menu.
By combining the simplicity of the original Macintosh with the power of UNIX, the original designers of Mac OS X did a great job in making something that was both easy to use for “mere mortals” yet powerful under the hood.
Can we take this design objective to new heights in helloSystem? Please leave your comments.
helloSystem is in pre-release status. Please see https://hellosystem.github.io/docs/developer/contributing for how to contribute.
