Some brainstorming to be further worked with. Happy to hear your thoughts.

Why is it that it is so hard to copy that mp3 from your iPhone to your set top box? Why is it that Windows and Android are annoying you all the time, notifying you about stuff that takes your attention away from what it is that you are trying to focus on? Why do fonts on Linux look so bad by default? Why is it that you have to install and configure stuff in Linux and it doesn't "just work"? Why is it that you have to sign in with Google, leaving your metadata, each time you want to get a new app for Android, and it is so hard to just distribute apps locally from device to device?

It's no coincidence.

It has to do with the fundamental values and motivations of who made those systems.

Update 23.10.2021: Here we have it in Steve Jobs' own words.

• Many commercial products are made for a reason - to make money by selling something to someone. Made by businessmen for consumers.
• Many open source products are made to solve a technical task. Made by engineers for engineers.
• We want to make polished products that are simple, beautiful, open. Made by designers for "mere mortals".

We want to start building "Hello" by reminding ourselves what we like, and especially what we don't like, in today's available systems.

---

Here are some keywords that came to my mind when thinking about aspects of today's commercial software interfaces that I am unhappy with:

• annoying
• distracting
• bubbly
• attention-grabbing
• condusive to consumption
• complicated (if you want to be in control)
• take away control (why can't you easily see what data is sent where?)
• thumbed-down
• optimized for advertising
• optimized for generating sales
• collecting data
• spying
• bloated
• uncharitable
• ripoff (e.g, fonts that are metrically compatible but look nothing like the original)
• commercial
• user is out of control (try to copy mp3 from your iPhone)
• hiding complexity (making it even more complex), e.g., by hiding the file system
• hostile (to libre projects)
• encumbered
• restrictive
• spammy
• short-lived
• ever-updating
• busy with itself
• moving target
• ever-changing for no good reason (where is this setting in the latest Windows this time?)
• fashionable (all of a sudden everything needed to be "flat" again)
• Inconsistent (Windows: hodgepodge of different toolkits)
• spying
• always-on
• battery-hungry
• slow to boot (e.g., Android can take many minutes)
• heavy
• not extensible
• planned obsolescence (e.g., unchangeable batteries; hard to add memory; cannot operate properly * without a constant stream of updates)

Apple products used to fare a bit better in some of those aspects, only to be worse in others, with an unofrtunate trend for the worse. Which calls for open source replacements. However...

Likewise, here are some keywords that came to my mind when thinking about aspects of today's open source software interfaces that I am unhappy with:

• Not for "mere mortals"
• engineering-driven
• cryptic (e.g., who understands the messages when a Linux system boots up?)
• esoteric
• non-obvious
• need configuration
• administrators
• freedom
• noting "just works"
• have to fiddle around
• complicated
• you have full control (but it's complicated)
• bad defaults (no love to detail)
• hostile (to commercial enterprises)
• cannot agree on anything (hence everything exists in 10 alternatives)
• technocratic
• frightening
• cryptic
• technical debt (/usr, seriously?)
• made for the moment
• ever-updating
• busy with itself
• a moving target
• ever-changing for no good reason (why is the wallpaper different now?)
• unaesthetic (hodgepodge of different toolkits)
• Inconsistent (no one seems to agree/standardize on anything)
• not on a human scale (e.,g., no one can understand nor handle all the files in a Linux distribution anymore)
• rtfm
• unintuitive
• low-level
• technocratic

And finally, here are some keywords that came to my mind when I imagined what the hypothetical Hello system wants to have/be:

• Zen
• minimalism
• concentration
• focus
• uncluttered
• aesthetic
• attention
• detail
• privacy
• condusive to creation
• powerful
• freedom
• calm
• openness
• architecture
• originality
• non-commercial
• polished
• For "mere mortals"
• user-driven
• puts user in control
• zero configuration
• "it just works"
• no administrators
• straightforward
• not limiting
• great defaults (opinionated)
• as complex as needed, but no more
• there is one standard way to do something (not 10)
• human
• inviting
• thinking and feeling
• understandable
• fresh
• clear
• simple
• easy
• unencumbered
• cultural heritage
• slow-changing, only updating one in a while and when the user so desires
• logical
• consistent
• on a human scale (e.,g., a number of files that humans can understand and handle each one)
• on only when needed, off most of the time
• self-explaining
• no manual needed
• lightweight
• modular (on a high level that makes sense to "mere mortals")
• frugality
• intuitive
• integrated
• high-level
• green
• no planned obsolescence (can do its job forever without requiring changes)
• extensible (attach a larger storage device and it will "just work" immediately)
• artistic
• fun

Ddesign and scientific ideals, bridging art and science

• "Less, but better" (Dieter Rams)
• "It’s technology married with liberal arts, married with the humanities, that yields us the results that make our heart sing" (Steve Jobs)
• "they have no respect for the status quo" (Apple Think different campaign, 1997)

The key is: "reduce to the max".

• Dieter Rams
• Otl Aicher
• Steve Jobs

Why do we accept the status quo in open source? We have beared with Gnome, Liberation fonts, system administrator thinking for much too long. Time to make open source for mere mortals.

Time to start clean. Start from today's capabilities, not from those of the machines 40 years ago. Don't optimize for the restrictions of today's machines, as Moore's law will help us.

Shall we call it "software minimalism"? This only captures part of the "less, but better" we are striving for.

Think about how the user wants to handle the objects on a machine.

• The system is made for the (=one) user, does not want to ever run into "permissions" restrictions
• Currently the user is in the wheel group by default and can use sudo, but the original Mac was even easier than that - a single user system... (like Haiku)
• System is not busy with itself and does not draw the user's attention to it (does not have to be "managed")
• "The system" = one file
• "An application" = one file
• Everything can be arranged in the filesystem at will
• More than one version of each app
• More than one version of the system on the same machine without complications
• Everything in sync all the time. (No "you need to regenrate the initrd if you change this file", "you need to rescan the library if you attach a hard disk with media to your media center" so that the additional content shows up.)
• The system is robust (e.g., can switch off power at any time without the risk of ever damaging the system)
• The system has a clear "home point" where the user always can return to (e.g., by power cycling)
• The system is environmentally friedly by being powered off most of the time when not in active use; this requires fast/instant boot times
• No way to configure the system in a way that it cannot be supported over the phone (everything is always at the same place for everyone and for decades)
• Everything works without logins, user IDs, passwords
• No central proprietary servers, instead: optional peer-produced/federated online services

• The Macintosh around 1984 (each file on the system has an understandable purpose and can be managed by hand)
• LibreELEC today (robust, most things work out of the box, no unclear messages when the system boots up)
• Mac OS X 10.0 (fresh design without legacy; simple to use yet not restictive)
• Ubuntu Live ISOs (a desktop system that largely "just works" without installation, without fiddling around)
• Zeroconf (devices find each other without fiddling around)
• Raspberry Pi automatic USB keyboard language detection https://gist.github.com/probonopd/9646c69f876ff2b4b879aeb1c1cbc532
• Alternatively, set language, keyboard, timezone,... based on IP geolocation (after asking nicely)

Maybe we should think beyond "desktop" right from the start:

• Productive workstations (Desktops, including notebooks)
• Mobile communication devices (Phones)
• Text comsumption devices (e-book readers)
• Large-screen video consumption devices (TV)
• Audio consumption devices (radio)
• Embedded (built into many kinds of real-world connected objects, e.g., routers, lighting, 3D printer,...)

Each should be usable standalone, but integrated so much as to regognizing each other automatically and making it trivially easy to interact with and share content between them.

I am not against "progress" but I think we need to reconsider what "progress" means to us. Looking at many real-world software products, I see a constant stream of change but little real progress. I think that less is more. We need "Less, but better" in the software world.

Great designs last decades and you can extend what you have over decades, without throwing out and buying everything again.

Examples:

• USM furniture
• ERCO lighting
• ...

Great procucts are timeless. Great products are "completely developed". (Know when your product is "ready", and then don't constantly change it just for the sake of change.)

We should make the same for software. This would be "progress" for me.

• William Lidwell: Becoming Leonardo, How Great Designers Think https://www.youtube.com/watch?v=rdH8Kuku9tA

• hello - Symbolizes the welcoming nature of the system
• Lagom - The word can be variously translated as "in moderation", "in balance", "perfect-simple", and "suitable" (in matter of amounts). Whereas words like sufficient and average suggest some degree of abstinence, scarcity, or failure, lagom carries the connotation of appropriateness, although not necessarily perfection. (A play on "simplicity is the ultimate perfection")
• Sosumi - the name is obviously Japanese and has nothing to do with computers
• Clarus, Moof! - the Dogcow