OK … day two and delving into part two of an article/post based on a “talk” given by Tobias Bernard & Jordan Petridis at the at LAS 2019 in Barcelona.

There is No “Linux” Platform (Part 2):

This is Part 2 of a series on what’s wrong with the free desktop app ecosystem and how we can fix it, based on the talk Jordan Petridis and I gave at LAS 2019 in Barcelona.

In Part 1 we looked at all the different elements making up a platform, and found that there is only one “complete” platform in the free software desktop world at the moment. This is because desktops control the developer platforms, while packaging and system integration is managed by separate communities, the distributions, for historical reasons. This additional layer of middlemen is a key reason why we don’t have real platforms.

elementary OS is the only “complete platform in the free software desktop world” mentioned above. In my part 1 post yesterday, I quoted one of the problems as being – “3) Ecosystem fragmentation: Every downstream change adds yet another variable app developers need to test for. The more distributions do it, the worse it gets.” Apparently, some Distros (e.g. elementary OS & Ubuntu), and some Desktop Environments (e.g. GNOME & KDE) are attempting to move away from the ecosystem Fragmentation and Disconnect disaster/s caused by a majority of the other some 2000+ Linux Distros, IMHO. Developers have grown tired of “middlemen” and radical Linux ‘Mobs’ screaming endlessly into their ears…so to speak.

(that’s clearly an example of ‘A picture is worth a thousand words‘)

Power to the Makers

Some of these solutions have really started to come together over the last few years, empowering the people making the software to distribute it directly to the people using it.

Cut out the “middlemen” & radical Linux ‘Mobs’ and allowing the developers to distribute directly to actual Consumers…that might work. Leave the “middlemen” and radical Linux ‘Mobs’ to feed upon themselves! Interesting that the only actual platform in the entire “free software world,” elementary OS, tries to get you to “Purchase” it before being able to download it. Good for them! However, Linux is up against a Microsoft Windows 10 Pro OEM CD KEY costing as little as $15.39 from sites like URcdkey.

1. The Host Still Matters

Even with Flatpak there are still some unpredictable variables on the host system which affect app developers. On the technical side a number of things can go wrong, from an outdated Flatpak version (which can mean some Portals apps rely on may be missing), to missing/incompatible system APIs such as password storage, calendar, or address book.

These things can lead to applications not working properly, or at all.

Just like “write once, run everywhere” is always an illusion, it’s never going to be possible to completely split apps from the OS. You always need app developers to do some extra work to support different environments, and currently every distribution represents yet another extra environment to support.

2. Downstream Drama

Flatpak does not completely solve the issues app developers face in shipping their software, because these can not be isolated from the ones desktop developers face. In order to fix the app developer story we need real platforms. In order to get those we need to resolve the desktop/distribution dilemma.

Well, it’s certainly not easy being a free software developer … I don’t know how they do it, with so much stacked against their success.

Forging Platforms

Given the constraint of there being multiple different desktops projects and technology stacks (and the host still mattering), we’ll never have a single “Linux” or “FreeDesktop” platform. We could have one platform per desktop though.

From an app developer point of view, testing for GNOME, KDE, and elementary isn’t as nice as testing only for a single platform, but it’s not impossible. However, testing for Debian, Fedora, multiple Ubuntu releases, OpenSUSE, Arch, Endless, and dozens more is not and never will be feasible, even with Flatpak. Multiple different distributions, even ones that ship the same desktop environment, don’t add up to a platform. But exactly that is what we need, one way or another.

The question is, how do we get there?

Hey, humble me is just an End User, so please don’t ask me!

The Nuclear Option

When we look at it from a Flatpak context, the solution seems obvious. Flatpak is solving the middleman problem for app developers by circumventing the distributions and providing a direct channel between developers and end users. What if we could do the same thing for the OS itself?

With Flatpak runtimes there is no extra “distribution” abstraction layer. There are no Debian or Fedora runtimes, just GNOME and KDE, because those are the technology stacks app developers target.

Well, I can’t keep up…very complicated; however, it appears that GNOME and KDE are the DE’s for End Users to start learning, since those two are heavily targeted by developers. As I mentioned in yesterday’s post, “GNOME and KDE are probably the future of the Linux Desktop Environment (DE),” and that has been obvious to even an End User like me.

Squaring the Circle

What could we do within the constraints of the technology, ecosystem, and communities we have today, then? If we can’t go around distributions with a platform OS, the only alternative is to meld the distributions into a meta platform OS.

Technically there’s nothing stopping a group of separate distributions from acting more or less like a unified platform OS together. It would require extraordinary discipline and compromise on all sides (admittedly not things our communities are usually known for), but given how important it is that we fix this problem, it’s at least worth thinking about.

Notice the “admittedly not things our communities are usually known for” – many Linux groups are filled with nothing but hateful radical users, and can’t even get along with themselves. GNOME and KDE were once fierce competitors, but have managed to set aside animosities in order to build for the future. With the fragmentation now within Linux, breaking away from the radical Linux ‘Mob’ seems like a good plan. They list some specific issues (some have been mentioned previously): 1) Release Schedule, 2) Theming/Branding (seems like a big issue), 3) System UX/API Changes, 4) OS Installer (Ubuntu has the best installer – most of the rest suck!), 5) Software Installation & Updates, 6) System Default Configuration.

The Bottom Line

If we want a future with real platforms we can either go around the distributions or have them all work together (or potentially both), but one way or another we need to vertically integrate.

Neither path is straightforward or easy, and there’s a huge amount of work ahead either way. However, the first and most important step is acknowledging that this problem exists, and that we need to radically change our approach if we’re serious about building attractive app ecosystems.

Good luck with getting radical Linux users to publicly acknowledge anything being wrong with *THEIR* Distro. Obviously, developers want change – Microsoft understands this simple fact, and has offered solutions…they even added a Linux kernel into their Windows 10 OS. Going around the “middlemen” & radical Linux ‘Mobs’ is the obvious way to have a healthy ecosystem across the entire ‘free software world’, IMHO.