Most people engage with FOSS for practical reasons, not ideological reasons. Given that developers of proprietary software have made a lot more money on the whole than developers of FOSS, I don't see that changing anytime soon.
Indeed, for software of good quality, free software wins. GNU R has completely dominated most areas of statistical computing, for example. The ideology is there not because we think you're "impure" or "evil" or something if you use non-free software, but because we think you'll be happier if you do, because you deserve it, because we all deserve free software.
While I wholeheartedly agree with this particular stance--doing away with ideology and sticking with ethics and pragmatism--, I am not sure that everyone in the FOSS community, if such thing exists, adheres to that same premise.
Free/libre software (e.g. GNU and the FSF) believe in "free as in speech" for ideological reasons, not for tech quality reasons. In fact -- they argue -- one should sacrifice convenience and sometimes even short-term quality in favor of freedom. I certainly see the merit of that line of thought, though it's also a very hard road, and harder still to convince people.
Ideology is not a bad word :)
Software freedom is not some abstract ideology with no relation to pragmatics.
What is good quality differs between people. Personally i consider good quality to be desktop software with a good and simple (but not patronizing) UX and responsive UI that does not abuse my system's resources.
The vast majority of FLOSS fails hard there, at best you get a single aspect of the application to be very good at what it does (e.g. some 3D renderer might provide a very accurate light model) but suffer at everything else (e.g. be usable only through the command line, using only a custom format, no support for the 3D authoring tools that everyone else uses, etc).
There are very few FLOSS applications of good quality and of course that is what i consider good quality (someone might consider the command line part i mentioned above as a sign of quality because it would be easier to drive via scripts, e.g. for setting a render farm).
Back in the '90s, when gcc really took off, it got a lot of attention for being faster and optimizing code better than anything else out there. It wasn't just free: it was _better_. Of course, the 'free' part helped too, but the only 'free' people cared about was as in beer, not speech. This was when Sun was charging $$$$ for C compiler licenses on top of the operating system. So you could buy Sun's cc for massive amounts of money... or get a _better_ product without having to shell out. No wonder gcc won.
And if you look down the road to the 2010s, when LLVM/clang is eating gcc's lunch, you have to wonder what went wrong. What went wrong was that gcc fell behind for ideological reasons. RMS categorically refused to allow gcc's frontends to output the AST on the grounds that proprietary tools could make use gcc's output. The developers of LLVM and clang, on the other hand, had no such qualms. Being able to get an AST out of clang meant you could have IDEs compiler-assisted syntax highlighting and real-time error checking, things that gcc will never have for ideological reasons.
gcc succeeded when it was better than the competition and faltered when it was worse, and freedom had nothing to do with it.
The concept seems obvious, but often times free software activists forget or are unaware of lessons like this. Because free software activists are willing to make sacrifices to preserve their freedoms, they sometimes forget that others are not willing to make those same sacrifices.
Getting end users and often developers interested in your project isn't easy. The vendor lock in proprietary software companies use makes it even more difficult to get users even if a free solution is better. The goal of a project should be to grow the community outside of just the free software community by improving the software until it's eventually better than proprietary alternatives.
That's why I'm particularly excited about projects like GNUnet, Guix, and Librem 5. I think they have the potential to blow the competition out of water and move the free software community closer to it's goal. https://gnunet.org/en/ https://www.gnu.org/software/guix/ https://puri.sm/products/librem-5/
RMS was wrong to have pushed back on module support for so long, but it was irrelevant. Apple wanted to be in the driver's seat, and Apple's legal department was and remains violently opposed to GPL3. And it turns out that when you're in the driver's seat you don't really need stable interfaces and you definitely don't need modules.
The competition has been good, though. I like using both compilers.
Sure, some developers will give their best for free... for some time. But sooner or later the going gets tough and maintaining (let alone developing further) your pet project becomes a chore. Will you still do it? For how long? And if you try to monetize the project to at least somehow offset the lost energy and time, and maybe even pay someone else to help you, then you figure out you can't. Because free / open / libre means that anyone can take what you did and run with it.
This is the reason why FOSS projects don't reach the maturity and polish of closed variants. The only exception I can think of is Firefox, because it is able to capitalize on its unique position where it threatens (a bit) Google Search. With Google also making its biggest rival.
And the end result is that while the FOSS software is free (as in freedom), its quality leaves much to be desired, so the users are not flocking to it. Far from it.
Until FOSS movement rethinks what "freedom" is, nothing is going to change for better. Maybe giving Commons Clause and other hybrid licenses a chance could be a way out? I don't know, but it makes me sad that I'm typing this on a closed phone without (realistic) choice.
The valuable good in exchange is the developers time, not the code itself - nation states have constructed a goliath IP apparatus to impair the natural capacity to instantly and infinitely replicate information. But its wholly fictional and fabricated - its just an outdated paradigm from the era of the commoditization of the printing press where there were still marginal costs that could endanger businesses to overspend on.
There are many ways to monetize your time while creating liberated code in the process, but that is where the focus must be in the free software ecosystem.
Ok, I don't even agree with your definition of freedoms, but I'll bite anyway. Do you have an example of a different approach? RedHat? Selling services, FOSS is just a by-product. Mozilla? Yes, though its position is very unique, and they are the only ones who really have incentives aligned with their users'. Redis? Mongo? MariaDB? Their change of license tells everything.
If it didn't work for myriad of projects in the past, maybe there's a problem with the approach?
As for other things... You must be living in a very different world from mine. (edit: this was not meant in a bad way... just an observation)
It is unsettling that they all get this success on a proprietary middle man that siphons a portion of the money in the form of Patreon, but the principle is absolutely applicable to development in general. Right now its regular people paying to have software they want to use developed - game engines, art tools, etc - but nothing should stop a culture shift from getting both corporations and private developers to start paying in a similar way for libraries and infrastructure given the means to correlate the added value in doing so.
Godot=$10k/month (patreon) Krita=$2k/month (their donation page) Blender=€31k/month (their fund page) GIMP=individual donations only for two developers, $1k/month and $595/month each OBS=$3.5k/month from opencollective, $1.5k/month for the lead developer for patreon
Now, i do not know what sort of standards you have, but to me considering the amount of effort needed to create the software you mentioned these sound like pittance with the exception of OBS (and even then the developer would get a lot more money if he worked as a developer on a regular company... in some places even as a junior).
$10k/month for a game engine of the complexity of Godot? For Unity that would be absolute failure even back when the editor was available only on Mac OS X.
$2k/month for an advanced complex image editor and painting application? Even in the 80s (and ignoring inflation) that would be a cause to close shop for any software development company.
Blender needs to reach €50k/month to hire 10 developers full time? I'm curious what part of that €5k/month actually goes to the developer.
I'm not going to comment on GIMP, it should be obvious how ridiculous those numbers are.
Look, these numbers are actually the proof of how bad the economic side of FLOSS development is. These are jokes compared to even a small startup, let alone projects that exist years for software used by hundreds of thousands (if not millions, for some).
Developers who work on those aren't doing it for the money, they are doing it because they love the work. If you want to monetize your work, FLOSS is not the way to go, especially as an independent individual.
If you crowd fund development instead of try to sell consulting or a premium version then Amazon can't pull the rug out from under you by offering hosting and support because you aren't in that business. You may never have an IPO or make a <doctor evil>billion dollars</doctor evil> but if as the song says we "Try just a little bit harder" We may be able to offer sustainable income from making free software.
The common clause licenses isn't a "hybrid" its a proprietary software license. Calling it a hybrid is like saying a BLT without the bacon, lettuce, or tomato is a sandwich. It's not a solution its giving up.
Well, it's more like tiramisu with chocolate instead of coffee. In the end, as a user, I would prefer a convenient and polished product (that I can't sell) to worse product that respects some other people's definition of supposedly my freedoms.
Agree that crowd funding is another way, yes. Probably works for very few projects (font awesome comes to mind) though.
Got any examples?
It does put some restrictions regarding the license for modifications (it must be permissive, or CLA needs to be signed), but anyone can fork, maintain or share their copy. They just can't make money by selling it, without also paying to original authors. Which seems fair to me.
Should contributors also be somehow compensated? Bigger ones, absolutely. How? I have no idea, but there's at least some chance of that happening with Commons Clause, while with FOSS there is none.
As for examples... From Commons Clause? No. But since Redis Labs changed the license for their modules I'm not aware of any projects using it. Unfortunately.
There are plenty examples in closed source space though... Windows, MacOS, Photoshop, Illustrator, Trello, GitHub.
Kubernetes (Google), Angular (Google), TensorFlow (Google), VSCode (Microsoft), TypeScript (Microsoft), React (Facebook), PyTorch (Facebook), just to name a few.