I would argue for the opposite: One problem with linux is that you can't run untrusted software without it getting the same access as the user. That's exactly what the appification is.
I see package managers as a source of some problems of linux: Package maintainers are a unneeded middleman between the writers of the software and you, package managers interact with the whole system, scattering files around the whole filesystem and running scripts as root when installing/uninstalling packages. Applications being files/folders that can be installed/uninstalled with cp/rm seems way more unixy to me.
High-standards imposed by distros (see for example: https://www.debian.org/doc/debian-policy/) and tedious work of packagers has been a very important part of the free software ecosystem, and kept GNU/Linux snoopware-, malware- and virus-free and trustable [1]. They are far from "unneeded middleman".
Here's a very recent example of this system at work: Chromium sneaks a binary blob which secretly listens to your microphone and sends data to Google: https://lwn.net/Articles/648392/
This is just one instance, there has been many many examples of this.
There are just so many, let me say, shady, "apps" out there, so I don't install anything from Google Play Store on my smartphone. On my desktop/laptop however, I feel safe installing whatever I need from the official repositories. I personally don't want to use a distro to which "app" developers from Android ecosystem can freely push their programs (and updates to them).
> Applications being files/folders that can be installed/uninstalled with cp/rm seems way more unixy to me.
But that's essentially what a package manager does for you, although it takes away your freedom to screw up in the process. In GNU/Linux, it essentially 1) protects you from screwing up your system accidentally 2) allows you trust system-wide binaries (assuming that your distro is trustable).
App Stores are also package managers, so I'm not sure what you're trying to point out here.
====
[1] I'm excluding Ubuntu here. Ubuntu comes with spyware, spies on you by default and monetizes the privacy and trust of its users [2]. I don't trust it, I don't use it, and I recommend against it.
E.g. if it can only do file accesses outside of it's own settings folder after prompting me, I know that it has way less abilities to screw up my system.
I don't think that can replace a package manager for "complex" or "infrastructure" software, but for other things it could open the selection up. Many people already run sandboxed applications, in sandboxes called "Firefox" or "Chrome".
Lately I've found myself checking if something is available on F-droid before installing from Google Play. Sometimes it is!
If something is on F-droid, I'm less worried about it being scammy spyware disguised as useful software.
Downloading a binary blob in the first place was the real issue. However, the voice recognition module wasn't actually used unless you opted into the "Ok Google" hotword feature.
Getting back on topic, Android handles similar problems in a different way, via the permission system (esp. the improvements in Android 6.0+).
So says someone, but you don't know what else the binary blob (which can be "updated" at the will of Google, without asking anything to the user) does for sure, do you? If you're content with that explanation, you're essentially taking their word for it with blind trust. For example, will it push a new binary and/or suddenly start listening to you or send certain files from your computer if someone three-letter government agency tells Google to do so? Would you bet your life on it?
Trust in software may not be that serious for you, but there are people out there whose lives depend on it.
The issue here is twofold, and in terms of security, it being a binary blob is the lesser one: 1) this is a binary blob which hasn't been vetted by the eyeballs of FOSS world 2) Google circumvents the package manager (along with package reviewers and FOSS community) and secretly and freely installs (and updates) a binary blob on your system, which is essentially a closed-source backdoor singularly controlled by a US company.
A program that silently pushes programs on users' systems (and silently executes them!) at the pleasure of a company never had any place in Debian or any distro with similar principles. It wouldn't matter if they pushed the source code and compiled it on your system (in fact, some rootkits work just like that).
> Getting back on topic, Android handles similar problems in a different way, via the permission system (esp. the improvements in Android 6.0+).
You're talking about a totally different problem/class of permissions here though (accessing network/video/audio/filesystem etc vs ability to install packages as a non-root user).
Of course you could say in a large codebase like chromium, bad things can be hidden. But at least there's a better chance such things are found, and it's more risky to put it there in plain sight.
In a perfect world, all software would have reproducible builds and there would be no issue with trusting that binaries contained no hidden functionality not in the source, as there'd be third parties to rebuild and compare the result against the published binaries. We're a ways away from that.
You can't use it to deny specific permissions, only groups of them. If an all wants to write something your contacts, you also have to allow it to read them. This even though the core permissions system allows that level of granularity.
also, network access is deemed safe (by Google) and is thus in a group of permissions the user has no control over.
It sounds like you'd enjoy Slackware's approach to package management. Zero dependency resolution, packages are built from the source tarball with little or no patching (unless you patch it yourself), and the files are installed where the author intended them to be (though that can be good or bad depending on your perspective). If the application has dependencies, you're left to install them yourself, ensuring that only the absolutely necessary dependencies are installed, and not, for example, all of Gnome when you just want a simple text editor.
> ...and running scripts as root when installing/uninstalling packages.
Given that this happens even when you build from source and install yourself (./config, make, sudo make install), I'm not sure what you're asking for. Perhaps the Mac OS X method of "the app is a folder with pre-built binaries and all necessary libraries"? And even some OS X apps require elevation to install, especially those distributed as .pkg files.
It's great for games in particular, given that you'll be able to boot up a 10-year-old game container-image as if it were new. (In that way, it's like game emulation, but without the performance drawbacks.) Most other "app" software gets lesser-but-still-significant benefits, in much the same way you see on e.g. the Mac App Store with their self-sandboxing apps.
There's little advantage in distributing system software this way, given that system software is usually full of low-level extension-points that other system software plugs into to achieve the purpose. And this is what can make a platform abstraction layer like Android make sense. With a platform, the system software is all composed together by the platform maker into an underlayer, and a single, clean API is specified atop it. Above the platform abstraction, there doesn't need to be any exposed runtime model for system software—since it's all been encapsulated into the black box of the underlayer. The platform only needs to specify a model for developing+running+distributing app software.
Sometimes things straddle the boundary, though. There are numerous cases of software that has "failed out" of the Mac App Store after a while, because the software is fundamentally a system-software/app-software hybrid, and sandboxing the system-software aspects just didn't work.
Have you heard of Nix and NixOS? It doesn't use containers for this, but each package's tree is kept isolated from the others'.
In other words: I don't just want my game from ten years ago to run; I want my game from ten years ago that was built for a RHEL-alike to run on the Debian-alike I've got today (or maybe even using FreeBSD's Linux-binary support.) Nix can't give me that, except by just being the particular tool that ends up putting together the packages that go into a container-image.
Nix can be used to exactly re-instantiate the same set of files ten years later, presuming the original Nix repo you found the software on was still alive ten years later. In that way, it is similar to creating a container-image. But for this use-case, it doesn't give you anything that the container-image doesn't, while the container-image does give you an assurance that a stable (sandbox-based) interaction model was defined at the time of the image's creation, which can still be used today.
Something that intersected the Nix package-management model with the Mac App Store "only self-sandboxed apps will be accepted" model would be strictly equivalent to containers, though.
The basic problem with most package managers is that they ignore the soname mechanism.
https://en.wikipedia.org/wiki/Soname
This allows multiple versions of a lib to live side by side, while giving the binaries the version(s) they want.
package managers ignore this, and instead is hung up on getting that one "true" version everywhere. This because their basic design only allow one version pr package name. Thus you can't have ABC 1.0 and 1.1 installed at the same time. Instead you have to mangle ABC into something like ABC1 to allow 1.1 to install without removing 1.0 in the process.
It's actually pretty straight forward to build multiple packages with the same name and different versions that can be installed side-by-side: it's like a single line in an RPM spec file, as long as the files list doesn't conflict. A lot of the required effort is in building the software that uses the library. The library's header files are not often in versioned paths, so the -devel package for multiple versions has conflicts. It's easier to specify the option to configure that installs all the files with a version suffix and just be done with it. It is, unfortunately, not in the interest of the person doing the packaging to significantly diverge from how upstream suggests it be installed in their docs. That is, what should happen is entirely doable but, as part of the larger ecosystem of software and packaging and distributions, it's complicated and has little payoff.
At least it seems to work wonderfully for daily usage on Gobolinux.
The issue I described is during build time of a program that uses a shared library. Given this list of available libraries:
lrwxrwxrwx 21 Apr 20 2011 libevent.so.2 -> libevent.so.2.1.3
-rwxr-xr-x 106656 Aug 20 2010 libevent.so.2.1.3
lrwxrwxrwx 21 Jun 3 2012 libevent.so.5 -> libevent.so.5.1.3
-rwxr-xr-x 277760 Jun 3 2012 libevent.so.5.1.3
lrwxrwxrwx 21 Jun 3 2012 libevent.so -> libevent.so.5.1.3
The "fix" is to move some kind of "logical" version number into the filename (although, which is "logical" and which is "physical" becomes ambiguous), like so:
$ ll libevent[-.]*
lrwxrwxrwx 21 Apr 20 2011 libevent-1.4.so.2 -> libevent-1.4.so.2.1.3
-rwxr-xr-x 106656 Aug 20 2010 libevent-1.4.so.2.1.3
lrwxrwxrwx 21 Jun 3 2012 libevent-2.0.so.5 -> libevent-2.0.so.5.1.3
-rwxr-xr-x 277760 Jun 3 2012 libevent-2.0.so.5.1.3
lrwxrwxrwx 21 Jun 3 2012 libevent.so -> libevent-2.0.so.5.1.3
The other way around this is to explicitly link against the full path /usr/lib64/libevent.so.2.1.3 and not use the -l option at all for this library. This works in part because of the -soname option you pointed out. While this works, and produces the same output if one could use -l to select the correct library file, most of the build tools we have at our disposal prefer to use -l to select libraries at build time rather than full paths (because if you use -l to select a system installed library, ld does the work of searching its cache and standard paths for you; however, you can get around this with the :filename version of namespec to the -l option). This means that some programs' build processes would be different on systems that have only the old, only the new, or both libraries on the system, and a bunch of programs build processes might need to change once the new version comes out.
The problem here is that -l only lets you specify the name, not the version to link against, under the (arguably well-founded) assumption that old versions should not be used for new builds but you need to keep them around for already-built programs to link against (dynamically, at run time).
I see you've qualified your statement with "most", so you're not in the wrong, but unless I'm mistaken both Nix[1] (and NixOS) and Guix[2] handle this problem well and do it in a way which scales infinitely.
Well, there's a million hobby project package managers, so I'm sure many of them fall in to that category. But the big ones, the ones used by the vast majority of linux users, don't have a problem with this (deb and rpm-based distros commonly version their libraries and install multiple versions side-by-side). This is a pain in the ass for the package maintainers as a lot of software developers don't think about versioning their API, but it's great for users.
You can install[] packages with libxyz.1.so and libxyz.2.so; you cannot install two -devel packages, because that package contains symlink libxyz.so to specific version.
Often, the system even installs such packages for you (they have compat in package filename, i.e. compat-libstdc++).
[] provided they don't contain additional files with assets, that conflict with each other. But this problem is not solved by gobo either.
* QubesOS, SubgraphOS, NixOS(?), etc.
Or even giving global access to functionality from a manifest file, without having to set up a restricted user/environment manually. (I wouldn't know without looking it up how to set up a linux user account that can't talk to the network. Or even better, only can talk to some part of the network.)
Meaning that "containers" just becomes a wrapper for things that can already be done, if one just learn to do it rather than pointing and drooling (as someone once referred to the GUI as).
Its one more thing that result in confusion between user and computer about the state of the machine.
The problem is that most app developers currently -only- distribute their app via Google Play, as it's the primary distribution channel that devices tend to come with. This isn't a complete lock-in, since you can still get those installed APKs from a device where they've been installed and archive them or reinstall them on other devices. (Refer to ApkMirror as an ethically dubious prime example of this)
Still, this is nothing to hold against Android itself.
I love F-Droid, but they plan to drop Firefox, and Chromium will never make it on there.
EDIT: Okay I did the Google search that I should've just done in the first place. Apparently they're not dropping Firefox fully, but rather forking it to "remove the proprietary binaries out of the official builds" (Google Play API, etc). I suppose APIs like that are important enough to your use-case that you need an alternative source for Firefox?
F-Droid has (temporarily?) taken down their Fennec fork, seemingly due to difficulties with development: https://f-droid.org/forums/topic/please-do-not-drop-firefox-...
This is presumably why Firefox's removal has been continuously postponed. Reliability is one of the reasons why I would prefer first-party Firefox over a third-party fork.
Though there are good reasons why F-Droid doesn't include Chromium and seeks to remove Firefox, the absence of many open source Android apps from F-Droid's catalog has a direct impact on utility. It's also not uncommon for apps on F-Droid to lag behind the version on Google Play or the latest release direct from the developer. (Again, there are good reasons why they screen apps, but it does impose a delay.)
I appreciate F-Droid's screening process, and I wouldn't want it to go away, but it'd be nice to have an alternative open source Android app catalog that's a little more liberal.
And even if after much begging you get a .apk from them, it often still won't work on a Google-free Android because it uses the damn Google API that requires the Google binaries that you don't want to soil your system with.
It might sound crazy when you consider some of the services typically installed with a package manager but ultimately there's no reason why an "app" cannot run in root, many root packages aren't actually installing drivers, they're only root for historical reasons (e.g. being able to read/write to /etc).
Why, for example, couldn't a web server be an app? Or a DNS client? Or a DNS server? Sure, there are certain system services which cannot (anything installing drivers/filter drivers/core UI/sound subsystem/graphics subsystem) but MOST things can.
I think its a step backwards, as you loose tight control over dependencies. E.g., in case of a security issue, one cannot easily patch all containers if they are blackboxes.
IMHO, the right tool for this is an improved package manager such as Nix or Guix (which incidentally also support containers in their own way). Perhaps the future should be a Nix-like package manager for dependency management, and container-ization for security and resource limits.
Containers fix a problem that unix has solved for decades.
https://en.wikipedia.org/wiki/Soname
The problem is the package managers used by most distros getting hung up on there only being a single version number of each package name installed at any one time.
Sort that out, like say how Gobolinux does it, and you do not need containers.
But containers is all the rage on the web these days, so ipso facto is also must be all the rage for desktop Linux.
Back before Gnome and Freedesktop, desktop Linux was a kernel up project. But more and more these days however it is a web down.
Meaning that web people get interested in using the L in LAMP on their desktops, start looking into Gnome/KDE, then get involved in Freedesktop plumbing, and all the while bring their web-isms ("move fast and break stuff" being the most annoying) with them further down the stack.
We supposedly discovered concrete 2 millennia ago but only adopted it widely 150 years ago.
I wouldn't diss people who actually have a shot at fixing the problem, even though you might not like their solution.
I use debian all the time, and the major libraries are versioned, and some have more than one version available. Debian is a very common linux distro, and through it, a lot of child distros get it too. AFAIK, RedHat and Fedora do this too.
So, do you mean that the state of adoption is bad for niche linux distros?
I've never actually used it, though, since Debian packages work fine for me.
If you're talking about binary compatibility, that's an issue for closed-source shops. With static linking, that isn't an issue that you can't workaround either actually (there are many closed-source programs for Linux such as thousands of Steam games). Distros will never put their binary blobs in the repositories, but companies still can (and do) publish .deb/.rpms (and third-party repos in some cases) for their programs.
Binary compatibility is an issue nevertheless, of course. But it is an issue that FOSS distros consciously don't care about, mostly because binary blobs taint a FOSS environment and stand against the underlying philosophy of FOSS.
It's not because Win32 is a superior API that games and big software titles are Windows only. For decades, people were force-fed Windows when they bought a computer, and they became a monopoly, much of it thanks to the deal they cut with IBM. It wasn't like people chose Windows. And Windows kept many big companies from making Mac/Linux ports with behind-the-door deals.
And Android didn't end up dominating the desktop either. Smartphone-land is a totally different and distinct user base. And the fact that it dominated over iPhone doesn't have anything to do with the API either.
For application developers there is a consistent set of APIs that are expected to exist in each version of Windows, Mac OS X, Android, iOS, Windows Phone...
On GNU/Linux one needs to bundle the libraries with the application, preferably static linked. But no one is going to do with with GNOME or KDE applications, for example.
Then there are the deviations each GNU/Linux distribution does from UNIX daemon management and paths.
So application developers are forced to choose a set of gold distributions and let everyone else to figure out how the application might, compile and run on their own system.
Steam, Mathematica, Mendeley Desktop etc. have long proven that stable API for GUI toolkit doesn't have to be an issue for users.
> For application developers there is a consistent set of APIs that are expected to exist in each version of Windows, Mac OS X, Android, iOS, Windows Phone...
This problem you're referring to isn't something inherent in or specific to Linux.
On Windows, the very same problem exists and is known as DLL hell. Android is another Linux distribution, and you're talking about Java programs running on top of a VM on top of it. Java programs work just fine on Linux too.
I belive you're talking about Cocoa and Win32 API.
On Unix, there is POSIX and X11 which go way back. And there are many GUI toolkits (including but not limited to Qt and wxWindows) that allow you to statically ship your program, with the added bonus of being cross-platform.
API isn't an issue that can't be solved for developers either.
> On GNU/Linux one needs to bundle the libraries with the application, preferably static linked. But no one is going to do with with GNOME or KDE applications, for example.
Yes, they can and they do ship statically linked binaries. While they don't generally use Qt or GTK, both promise binary compatibility with a major version.
They don't need to make it a GNOME or KDE apps to run it under X11.
> Then there are the deviations each GNU/Linux distribution does from UNIX daemon management and paths.
Can you be more specific about the problem you're referring to? Are you talking about a particular closed-source daemon program that uses something other than /etc/init.d or systemd (which has sysv init compatibility layer)?
If you want to criticize the GUI aspect of Windows, you should target the lack of any standard modern GUI API calls that don't involve using Direct2D or GDI+ (by modern, I mean full support for transparency and anti-aliasing, among other things). The old API, plain GDI, was standard and well-understood, whereas the newer improvements are completely different types of layers built on top of GDI. That's the real mess.
Win32 is more like Qt and if we could just fucking standardise Qt as THE API to target, everyone would be much happier. But of course then the Gnome devs won't be happy. The Linux desktop would be in a much better place if Gnome was dead.
To consider you example with text, in Windows, you also have to use GDI+ or Uniscribe to have at least passable text (without shaping, that is). Or use DirectWrite, which is about as old as Pango.
Even OSX went through changes, AAT/OpenType wasn't available when QuickDraw GX was all the rage.
I had high hopes for Jolla but I doubt they're really out of their financial troubles - they owe me a very expensive tablet, currently. By the time it's delivered it will be obsolete.
They should have worked out a viable business model with an open Sailfish.
It's Sailfish.
I would actually say that Linux distributions pioneered the app store concept via "yum install" and "apt-get" and such. Linux is certainly the first OS where I can remember seeing a centralized app repository you could pull from with a single command.
A new Android OS and your favorite software is installed in minutes compared to traditional desktop oses and their awful combination of command line and gui crap.
This is not so much a technical issue. Sure, the technicals need to be there, but when the average consumer goes looking for a computer, they don't start with the question, "How stable are the apis for this OS?" They do not know what an api is. And developers will not develop just because of stable apis. The Windows phone has not been a resounding success, but if ever there were a product that I, as a developer, would target due to expectations of stable apis, that would be it.
Appification is why my dad uses the iPhone. He can do cool things by hitting squares with his finger, and then get on with the rest of his day which will likely include a lot of mentally draining tasks. It's the same thing that gravitated folks to Apple's first graphical operating system. The user friendliness. The approachability. Not the cutting edge object oriented software behind it. But the mouse and a picture of a garbage can.
In that context, it's not foreign at all. I'm mean, the first time I saw the command line, that was foreign. But now it's not. But hitting a picture of an envelope to send mail, not so foreign.
It's based on open source Android (incl GNU GPL parts) and yet doesn't publish the code. They shrug off such questions in their official forum.
Count me out.
On the one hand, it has created a nice software ecosystem by pushing a consistent set of APIs. Linux desktop applications were never remarkable except for a few ones. I think fragmentation into a myriad of frameworks led to this. The only 2 X11 applications I use are firefox and zathura.
On the other hand, too much stuff has been redone in Android. It's too foreign. I would prefer less app-ification, less stores, more package management. And no mothership, no Google.