We Need to Save What Made Linux and FOSS Possible(linuxjournal.com) |
We Need to Save What Made Linux and FOSS Possible(linuxjournal.com) |
For the most part, Copyleftists are stuck in Hobbyland and it really shows when you look at the software they produce. Their business models - if they even have one - largely don't work. Given that software is very expensive to produce, copyleft software eventually runs out of suckers to support it after the "fun factor" wears off and the "real work" starts.
The Linux kernel is the major exception, but only because the particular exceptions that the GPL grants to it do not encumber the enterprises that develop Linux. Wherever it does, enterprises will choose non-copyleft alternatives (e.g. Sony and Nintendo building on FreeBSD).
Abandon all hope.
They don't want to find, audit, install, and evaluate dozens of obscure third-party extensions to make their OS usable.
They want options for setting their background image besides Fit to screen.
And they want to be able to use their friend's computer without having to learn how to use all their friend's customizations.
Nothing says that all free software will be good or user-friendly (systemd is an excellent case-in-point). But you can choose a better alternative.
Proprietary software sometimes has short-term convenience benefits, but even thinking slightly-longer-term quickly shows that it's never worth it.
Even with less-than-ideal software like systemd, it's still miles better than proprietary alternatives. Yes, you may have to run "systemctl suspend"* to put your computer to sleep, but you don't end up with Candy Crush embedded in your program launcher, or over-12-years-outdated bash, etc.
[*] It's pretty easy to wrap 'systemctl suspend' in something friendlier, such as a shortcut.
It would be nice to have an OS that's actually fun and intuitive for normal people (nevermind me), not stripped down and sanitized, and also doesn't have corporate bloat and massive data collection by default.
And multiple monitors hasn't been anything but a pain either.
I was told that Ubuntu is about as friendly as Linux gets. Sure, it's more usable than say Devuan or OpenBSD, but that's nothing to brag about. It's nowhere near ready for primetime.
The author seems to be mixing the use of FOSS in the professional world with the use of FOSS in their personal world.
In a professional environment, there is no room for "modeling your values". It sounds harsh, but that is the way it is. You use what works. Yes, Linux OSs do some things better than Windows OSs, and vice versa.
To me, Searls' point is that an overwhelming pressure to monetize everything has corrupted the health of the open source community. This is not just holier-than-thou moralizing; there will be real financial consequences if the creators of open source products don't start eating a lot more of their own dogfood.
I agree, and perhaps my parent comment itself was harsh and looking at this from the wrong point of view.
I think I perceived this article written in a more romanticized way than necessary. If there is a concrete, financial detriment to FOSS developers, then I would advise to make that point upfront.
If the problem is "There is too much monetization within the open source community", then many of the points in this article sound like symptoms or variants of the problem, rather than isolated problems themselves.
As a young adult who had a roof over their head by default, I was 100% FOSS and installed Gentoo on anything I owned that could even limp its way along that path (and discarded devices that couldn't), I refused to use proprietary messaging tools and social networks, and I accepted that I had limited myself to the social and economic opportunities that these things allowed me, as a sort of altruistic techno-hippie.
Now I am on LinkedIn, Slack, on a Mac and an iPhone, backing up to a proprietary NAS, operating most things in Amazon's or Microsoft's clouds using managed services that lock me and my clients in to their ecosystems, running default OS on most of everything. The technology choices in my day job are made by whoever has the power to make them, for whatever reasons those people may have -- and "freedom" or even "sustainability" for that matter are pretty low on their list of priorities. The technology decision in my home life come down to "what do I have time and energy to put up with?" and "is there a risk that I'll have to fuss with this in order to make sure it's operational when my wife wants to use it, late at night on some weekend when I'd rather be relaxing?".
Maybe when and if I return to a survival-by-default - when the mortgage is paid and health risks are (well enough) accounted for I'll be able to "model my values", but probably not before then. Even that might require a divorce, in adult life one's motivations and their consequences are not solely one's own to keep.
Aside from that, given the experience I've had with FOSS, at this point I doubt even if I were 100% financially independent and early retired if I'd go back to participating except to go to low effort to upstream fixes to my own problems (here's a patch/pull request, if you don't like how it's indented or documented, that's your problem to solve, not mine). The incentives are all awful with so many volunteers trying to create software for users or use cases that are fantasies, bike shed arguments, corporate interests trying to get their way and take advantage of free labor, corporate leech organizations saving millions in license fees for proprietary software and contributing nothing but sassy bug reports, the folks who are militant and awful to each other about inclusion/exclusion topics, well-meaning but ignorant people who refuse to understand their behaviors and words cause others grief, projects with lack of vision, leaders who are reluctant to lead.
Further aside still, there's a reason normal human beings don't use free software or decentralized whatever and it's because the developers of those things don't have the resources or vision to build software for normal human beings: people who won't edit a config file, won't author content in Markdown, don't want to read a man page of flags to understand the permissions in their chat channel, don't want to have to have a tower PC whirring and heating up a corner somewhere in order to solve what seem to them like simple problems, etc. etc. etc.
If the problem is that the ruthless winner-take-all nature of professional environments is destroying open source, then you need to fix both problems, not one of them. Trying to fix only one won't help.
1. https://help.ubuntu.com/stable/ubuntu-help/shell-exit.html.e...
That's no version of Windows, in my experience. I suffered through Windows 3.1x to XP to Vista to Window 7 (and tried out Windows 10), and none of these were fun or intuitive, certainly not compared to what I used immediately before (Atari ST) or immediately after (Ubuntu Feisty Fawn).
In 2019, Ubuntu is far more intuitive and manageable for an ordinary person. No going to the internet to download dubious software (or getting malware through the Windows Store, as per my Windows 10 experience), no weird Candy Crush and 'telemetry' (data siphoning) or any of that Microsoft sort of goodness.
Ubuntu is all business all the time. A five year old would get bored of it within five minutes. iPads are probably crack cocaine in comparison.
Settings doesn't even have an appearance and personalization section. Ubuntu is more stripped down than a Holocaust victim. And there's nothing fun about the Holocaust.
Why is that? Why have users chosen those environments? Assume they are rational beings, and get at the heart of it. Ask: "How can we address the actual user needs while supporting our goals?"
– Many Linux and FOSS geeks today use Linux only professionally
Same answer as above.
– We're not modeling our values
WHY? (Hint: "the use of nonfree" is not, and has never been a primary human motivator even for many people who "get it".)
etctera.
Finally, regarding the below... only one of these, the first, even tangentially touches on the user experience. There's an implied expectation of so much FOSS advocacy which reduces to "by writing and using our software, you will be wearing a hairshirt for the cause". This mindset is guaranteed to fail in front of users, who are by and large "non-believers".
"Having real-time chat is absolutely essential to the advancement of free software."
"We're the resistance now." "We need to create mass movement."
"Volunteer to write free and open code, to participate in communities."
"If you didn't live the history, learn from those who did."
"If you did learn from history, teach those who need to know it. Respectfully."
"Be patient. Remember that the tortoise won not only because it was patient, but because it ignored insult, ridicule and dismissal."
"Model your values. Use free software and hardware."
"Remember always how 'the rights to copy, share, modify, redistribute and improve software' are fundamental rights that matter to people."
"Work to convince developers that their software freedom matters."Because they don't give a rat's ass about the freedom aspect of free software. If software A requires four clicks to do something, but B has a way to do it in 3, they are on B without a second thought.
But in this case, those users are not just any old end users; the are actually supposed to be FOSS developers, so there is a heavy irony there.
I think what is doing on is that large numbers of people are now "reluctant" FOSS developers. They do FOSS because someone told them to. They got a job somewhere and the job involves writing code that gets upstreamed somewhere and is redistributable. Well, they don't give a damn about that, it's just a job, no different from working on proprietary software. Or they work on some proprietary stuff, but it interacts with and depends on some FOSS pieces so they get in there and make changes out of necessity, and those changes are freely licensed only because they are derived from a work which requires that due to copyright doctrines about derived works.
It's partly a generational thing. Notice how Doc Searls looks about fifty-something. He remembers a grassroots free software movement which was about actually about displacing proprietary software and liberating the user, and not about about providing reliable commodity middleware for locked-down devices and cloud services.
If you were born after 1990, you don't know a world in which Linux and other FOSS wasn't used for making locked-down tech, and proprietary web sites that lock in millions of people and step on their privacy. So of course it's hard to understand someone like Doc Searls.
The free software ideology originated in a world in which you still installed applications locally and ran them on local data, on a machine where you were allowed to stick in a floppy disc with any piece of machine language in its boot sector that could easily take over the machine. The machine that was understood to be owned by you once you paid for it.
Isn't this kind of the point, though? To compete with proprietary software, free software needs to actually be competitive. "It's not as good as this other (proprietary) software, but it's free" won't cut it.
> Because they don't give a rat's ass about the freedom aspect of free software. If software A requires four clicks to do something, but B has a way to do it in 3, they are on B without a second thought.
Convenience always wins. Always. Users do care about free (as in beer) and they care if the product or service will disappear without warning (hello Google!). But the definitions of FOSS are so strict that they harm developers, and thus products, and thus convenience for users.
OP is describing the symptoms of this phenomena.
It's attitudes like this that make people really not care about FOSS. Yelling at people because they're not using IRC instead of slack isn't a good way to convince anyone.
The difference is usually more like "software A requires an hour of setup and constant maintenance on a dedicated VM or container due to dozens of dependencies, and software B requires 3 clicks"
the thing is, their leaders may actually understand FOSS and believe in it because they can see the benefits, but they don't understand that for the developers below them it is just another job.
i have argued that exact point in a company where i worked, telling the leaders that if they want to get the developers to make actual voluntary contributions and participate in the FOSS community the leaders need to set an example and actively motivate the developers to do so.
just assigning someone to work on a FOSS project is not enough to help that person to join the FOSS community. there are exceptions of course, where someone interacting with the community realizes that there is more to it and becomes drawn into it, but that's not the norm.
Free software made cheap, network centric computing feasible. This led from a model where the user ran their applications (open or closed) on their machines to one which turned the user's machine into a dumb terminal to access the network. This resulted in defacto loss of user privacy and control.
In a world where Windows was dominant and you had to pay a per cpu licensing fee, would companies be trying to put everything on the web, or would they create more apps that ran locally with some network based syncing? It would have been a smart computer, dumb network world instead of the dumb computer, smart network world we have now.
One of the great ironies of computing is how free software in its quest to enable user freedom actually enabled a world with less defacto user freedom than before.
Because of the mentality that UX problems are just "the user being lazy"
IRC stopped in time. Linux desktop is a mess and have very weird ideas about UX (especially Gnome, they love making things "simple" by shipping a car with no gearbox but only one speed)
"Freedom" is a "cost/quality" like any other, some people might value it the most, some people might value it the least, but it is less important than other factors.
Someone might contribute a nice screen layout, but actual design of a user experience involves design, which is usually a process of intelligently deciding on limitations.
Slack and iTunes often get smacked around for their designs because they are kitchen sinks of features, which makes them bulky and non-intuitive.
Open Source communities tend toward this sort of kitchen sink by default. This is because people are contributing the features they want and need, not the ones which fit into your product plan. So you typically see the most success for software that is under an open source license but has limited or banned the ability for people to contribute.
There are good examples of UI in free software. There are also terrible examples of UI in proprietary software. A lot of the peculiar user experience in GNU/Linux is that way because it was cloned quite exactly from a proprietary system called Unix. A lot of that bad user experience is standardized with an IEEE standard called POSIX, which isn't free.
IRC has, in the past ten years, fallen behind on:
- Scrollback syncing (client-to-client) and persistence (server-to-client)
- Everyday user interface (mIRC ships a UI from 1995)
- Setup and configuration (I can't get SASL right on the first try and I helped upgrade an IRC network to support it)
- Authenticity at a network level (not just Anope setting a umode)
- Protocol resilience (netsplits should not be visible to users)
- Defense against attackers (pitting the idealism of anonymity against the safety of identity)
Why has FOSS allowed itself to be eclipsed by closed-source chat providers in these regards? I believe it's because the ideals of FOSS are now in direct conflict with the needs of modern users, including FOSS people themselves. For example:
- Anonymity is an ideal to be held up above all others, so defending against spam attacks is impossible, because anonymous users are granted equal rights as my friends.
- Accuracy is an ideal to be held up above all others, so preventing netsplits is impossible, because the clients must know when they don't have a realtime immediate connection to each other.
- Maximally-capable UX is an ideal to be held up above all others, so building a less-capable UX that is more widely easier to understand is impossible, because otherwise we might not be able to view our chat at the maximum information density possible.
- Local-only data is an ideal to be held up above all others, so scrollback syncing must be outright prohibited and campaigned against, because otherwise the clients would expect the server to help them exchange data that the server must never permit itself to hold.
If FOSS realigns its ideals with those of modern users such as ourselves, then it could easily retake the gap covered in the past decade by closed-source software. I hope with all my heart that it does so someday, but I'm not holding my breath.
Footnote: Apologies for all the whitespace but, ironically, HN doesn't support formatted text such as bulleted lists, nor does IRC. This would take up half as much vertical space on your screen on Slack :)
I use Slack, Facebook, Twitter etc. because I want to communicate with other people who use those services for communication. If I only use IRC and email, I would miss out on some of that communication.
I don't know the various reasons why each of those people use them, and I agree that it is, in part because of some of the things you mention. However, it is also probably also down to marketing. Many people use XMPP via Whatsapp without knowing it, they are just using Whatsapp.
The user accessibility problem is not universal to all FOSS. In my opinion, LibreOffice (MPL) is a superior office suite in terms of usability to MS Office. Audacity (GPL) has a simpler UX than many proprietary audio editing suites.
Except: They aren't, so you won't get at the heart of it if you make that assumption.
People simply are extremely short-sighted. People choose the "convenient" proprietary solution for the same reason that they elect the "convenient" dictator or for the same reason that they choose the "convenient" SUV ... what all of those choices (and countless others) have in common is that long-term costs are simply ignored when making the decision.
It's actually just a lie that proprietary software is more convenient. What is true is that it (oftentimes) is more short-term-convenient, i.e., you will save some time/effort right now. But the pretty much universal goal of the proprietors of proprietary software, and in particular of proprietary platforms, is to use that short-term convenience (which they optimize for) to establish themselves in a position of power, which they then use in the long term to maximize the profit while inconveniencing those they have managed to gain power over in any way that promises profits.
The most pernicious form of that long-term inconvenience is the "invisible inconvenience", namely the inconvenience that results from hindering innovation by hindering competition: It's inconvenience that you never notice because the more convenient alternative simply never gets developed, so you never get to experience the difference between what you do have and what you could have.
Why? Why import the concept of homo oeconomicus into this discussion?
As a long time FOSS and Linux user I can tell you that usability of FOSS GUI systems has repaidely degraded in comparison to professional systems (Mac OS or Windows). If half of my hardware is defunct under Linux I will not use the FOSS. It's like buying anew car and being unable to switch to fourth and fifth gear or use the built-in entertainment system.
The Wayland fork hasn't contributed to this situation.
This one in particular worries me. Having access mailing list conversations and IRC logs provides such a rich history of open source development. I worry about every open source project moving to github / slack, where we may not have nearly as good a record of conversations that formed the software in 20 - 30 years.
On the other hand you won't see any argument from me that these services provide an easier workflow than what existed before, and maybe that easier workflow opening development up to a wider community is more important.
It's a problem that can be remedied, provided the projects stop pretending that the packagers, technical writers, GUI/UX artists, and community managers are expendable.
The problem is that development is an extremely special purpose--one that most people don't do and don't understand the needs of. As a developer, I want a level of control over every aspect of my computer that most people don't want, need, or even think of. To most people, "general purpose computing" just means their computer (or more likely their phone, these days) can run any app they want it to run. It doesn't mean what Searls (and the people whose articles he references, like Doctorow) takes it to mean.
And to the ordinary person, the idea that it is essential to society that developers have the freedom to configure their computers however they want, regardless of what the government or some corporation says, doesn't sound like something worth fighting for; it sounds like something scary. They don't think of Stallman developing Gnu or Linus Torvalds developing Linux; they think of computer viruses and worms running rampant.
Software, and information in general, have been a prisoners dilemma for time immemorial. The optimization of utility is total freedom of information - but such a state of affairs means benefactors reap the labors of others and have no obligation to give anything in return.
Copyright was fabricated to solve 18th century problems with an 18th century bureaucratic solution. The whole free software movement in general emerged as a counterculture to how intensely harmful to society that policy influenced the natural state of affairs to become.
If anything, the fact free software enthusiasts have lost sight of what the ultimate goal has to be - the abolition of copyright and institution of basic standards of living for all citizens derived from the productive gains of the extraordinary multiplicative effects technology, itself derived substantially from free software, produces - is what really needs to shift. Anything less keeps the movement in an atrophying limbo where fresh minds join, put in their best effort, and fall out from the captured value innovation produces in our society.
We need to move towards a state of affairs where enthusiasts can produce freedom respecting code because they want to, that don't go hungry or homeless for their efforts, and where all of society can reap the benefits of theirs (and billions others) generosity and compounding efficiency produced through technological innovation. And where everyone has access to the fruits of those labors regardless of means as a way to improve the collective knowledge of mankind for all the rest of us.
Just think for a moment of the bizarre world where the brightest need not toil to manipulate tired and depressed minds psychologically to siphon scarce money from them to line the pockets of robber barons masquerading as productive members of society, but instead could comfortably collaborate towards actually making the world a better place.
- A website with a silly name like 'Facebook' is worth half a trillion dollars and is extremely profitable.
- A website with a silly name like 'Twitter' which only lets you post 140 characters at a time is worth 30 billion dollars.
- An app with a silly name like 'Snapchat' which loses billions of dollars per year is worth almost $15 billion.
- An international taxi service with a silly name like 'Uber' which is losing billions of dollars per year is worth almost $100 billion.
- That software developers don't see anything wrong with building apps on top of proprietary cloud APIs (e.g. Amazon Lambda) - The closest real-world analogy that I can think of is that it's like building a house with your own bare hands for years and then, once you finally finish it, you start paying a corporation rent (at whatever rate they ask for) so that you can live in your own house! Meanwhile, the whole time, there was an even better plot of land right next door which was 100% free but you ignored it because the signposts on the corporate land were flashing with bright neon lights.
The economy makes so little sense that there is no incentive left to create value. The best you can do is just look for the next financial scheme to take advantage of. I bet it will be something completely random and useless.
https://resources.whitesourcesoftware.com/blog-whitesource/t...
Using AGPL instead of GPL closes the Saas loop hole.
Also due to close to zero bank interest rates the general availability of venture capital is to some extent stopping new open source software. Instead of giving away your software for free as Open source software you start a venture capital funded Software as a service instead.
In spirit maybe, but not in practice because of its loopholes. That was the reason MongoDB changed their license.
Fact: most of the contributors to the Linux kernel are highly-paid professionals who do that work full time.
The same goes for many, if not most, of the popular and successful FLOSS projects.
It is an error to assume that free (as in speech) software is only made by free (as in beer) development.
But I have no clue what you're basing your second claim on. There's huge amount of FLOSS programs that work fine, are useful, but don't get much contributions. And I don't know about any studies/overviews on what number of programs say in a Debian distro is a work of passion, and what is created by paid devs.
But if you do that, it would also be interesting to trace free software back to the point where the GPL became popular. (GPL was published in 1983, but in my recollection it wasn't until the early/mid-90s that it surged into general usage.) Before that, 'free' software generally meant public domain: no licenses, no limitation on use -- at all. We had two or three decades of free software of that type, mostly distributed over Usenet, BBSes, FTP/Gopher, etc.
I'm probably being too oblique, but I believe it's short-sighted to believe free software must only be ideologically free. There was, in fact, an earlier period, where developers release software for free because, well, why not?
Okay, time for this retired grumpy programmer to retreat back to his hut in the forest now...
There is also an ahistorical perspective of tech, as if things just are or happen with no deliberate effort and its an open question whether there is any real commitment or concern for the principles which drove the open source movement.
In many ways Slashdot defined the original generation and Hackernews defines this one. And even paying lip service to principles would be quaint here. Defending building surveillance systems and stalking people 24/7 while referring to general users as idiots are often the top voted comments. This is a huge shift.
Dave Taht • 44 minutes ago We really, really, really need a return to our core values I remember how fired up I was in 1999, when I wrote this - https://www.youtube.com/watch?v=KxLbNCB-YKI and how fired up I am now to try and get our internet back. Still it is hard to be a revolutionary with two kids and a mortgage, and we've lost most of the next generation of coders to javascript and student debt.
I seem to recall this being true on Slashdot also.
I've used Linux or BSD on all of my personal machines for a long time, and assumed, wrongly I guess, that most other people were in the same boat. I'm not sure it's a problem, but it's interesting.
I'm puzzled. I think it was just the unfortunate rise of mobile.
They are formulated on an irrational fear of FOSS being extinguished by the greed of the corporations.
So long as there is at least one programmer left with the will to post their source to the world FOSS will not die.
Let's also not be so one-eyed as forget to value equally the contribution of all programmers who write great software whether free or not, open or closed-source - we can still admire the fruits of their labours if not their algorithms.
FOSS community, please stop wringing your hands in fear, go write some code with them!
But the world of proprietary software (including permissively licensed open source software) just moved faster, because its associated business models gave it the money, incentives, and the early signals needed to attack problem spaces in human-computer-interaction and secure, managed application platforms, among other things, that FOSS didn't have the resources to address, and so it just fell behind in key areas relevant to users.
We just don't know what the FOSS movement could have achieved given similar resources (or how it would have gotten those resources in the first place without a business model), or a lot more time.
I see we are still debating the same points as many years ago (GIMP vs Photoshop, Visual Studio, paid vs unpaid labor, chicken and egg, convenience...). It’s like we haven’t learned anything.
About the end of general computing, I don’t see it as a bad thing. In some way it has always existed. Right now we have server computers, desktop computers, smart phones, mainframe, cloud... even on a single class of computer we have some segmentation. It just means we’ll have even more specialization. And FOSS still can have a place there.
Speaking about that, I believe FOSS is stronger at the foundational layers.
Maybe the future is kind of and hybrid model in which we have lots of new computer classes with FOSS as their foundation. Not very different from what we have now, just much more diverse and, I hope, more open.
Would be nice if they replaced Disqus with e.g. https://commento.io/ though.
I suggest that the FOSS community now finally starts building something convenient for themselfs instead of making things hard and massochist.
The comment section of this article: "Our discussions are powered by Disqus, which require JavaScript. "
What wonder what we use if majority of computer is intel based and they have a parallel computer controlled your cpu?
Strangely arm is sort of open what can you pay to develop your own total open env and ...
Any further, wonder what is open source movement is all about if not asking for a mixed environment ? It is the dying middle that might be the problem or is there no problem. Wonder.
Just having open-source (or free software) alternatives doesn't necessarily solve the problem. Gitlab and Zulip still leave your data scattered around back-end DBs which may not be terribly accessible in 20 years' time if the software itself doesn't still run.
For chat apps, I don't think the problem of "data scattered around backend-DBs" is a real concern. E.g. Zulip has a well-defined data export format that's easily parsable JSON and contains all non-transient data (i.e. the status of who's typing right now isn't included): https://zulip.readthedocs.io/en/latest/production/export-and.... And so do most of the other popular chat systems.
I'd be surprised if Zulip doesn't still run in 20 years, but in any case, we have data import tools for the export formats of Slack, Mattermost, Gitter, and HipChat, and ultimately it wasn't that much work (The most recent few we've added were each a few person-weeks' work). So I think we can safely assume that at least for chat, it'll be possible to import the history.
But even if they don't, there are already scripts to export the public history of a Zulip organization and turn it into a webpage that can be hosted wherever (see for example: https://leanprover-community.github.io/archive/).
The https://zulipchat.com homepage and https://zulipchat.com/for/open-source are relevant reading for folks considering Zulip for their open source project.
The fact that we're just sort of expecting everyone to slave away on github every night and weekend to remain employable is pretty disgusting too. That's not sustainable.
Mozilla is a bad example because their leadership is simply pathetic, but you get the point. This trend is very, very dangerous. But well the writing was on the wall when many open source projects started moving to github.
You don't need to host your own server or anything special (unless you want to). You can just sign up here: https://riot.im/app/
In my opinion IRC is still the best tool out there and I really, really wonder why we stopped using it.
Even when that attitude isn't so explicitly directed at users, you're right about it being visibly directed at other community members. It all sends a clear message, such that the average prospective user will move on, thinking "that application is meant for someone else."
In addition, responses like that do more to specifically push people towards commercial software than anything else (not specifically proprietary, just commercial). Why use a piece of software where the developers have no incentive to care about your concerns when you could instead use a piece of software where you're a paying customer and the production company has a financial incentive to keep their paying customers happy?
Since the launch of Windows 10, Microsoft has been surprisingly responsive to customer requests. They have a ticketing system where customers can submit new feature requests, and if it's both reasonable and popular enough, they'll implement it. Here's a reasonable example: a while back, they decided to eliminate the split mode from the virtual keyboard because they thought nobody would miss it, as they added a swipe keyboard to replace it. Well, it turns out they were wrong, because lots of people opened tickets with Microsoft asking for it to be put back. They put it back in the next update. They listened to paying customers. Compare this to GNOME, on the other hand, which regularly removes popular features and ignores all user complaints.
Free Software originated in the hacker community—which is a community of developers developing for developers. It's always struggled to extend those values in a way compatible with the rest of the world. Notice that developer tools like GCC or Linux are the big success stories of Free Software, whereas end-user tools like OpenOffice or GIMP have always been kind of…meh.
Substitute software freedom with open source and I'd agree. But software freedom is a whole other thing that is valuable to non-developers. Proprietary software can cost money, require subscription fees, make older versions no longer available, add all sorts of licensing costs like per CPU licenses, restrict features to "pro" versions, etc. Those are issues that affect people (and large companies) that will never read the source code.
Free software is about user freedom, OSS is just a means to that end.
That is akin to saying that democracy is fundamentally valuable only for politicians, because only politicians can use the freedom it gives.
That is simply completely wrong. You don't have to be a developer yourself in order to benefit from not being dependent on a monopoly. The fact that you can buy development work on the free market benefits every user of Free Software. The fact that the code of Free Software is easier to inspect benefits every user of Free Software.
There is no need for everyone to be a politician for democracy to be generally valuable, there is no need for everyone to be a car mechanic for freedom to repair cars to be generally valuable, and there is no need for everyone to be a developer for freedom to inspect and change software to be generally vaulable. Those freedoms are what enable free markets instead of monopolies.
It may be worthwhile to reflect on my own early experience with computers. In 1988, when I was almost 8, my family's first computer was an Apple IIGS. As I explained in my personal retrospective on that machine a few years ago [1], that machine had kind of a split personality, because it combined compatibility with the earlier 8-bit Apple II models with a more or less Mac-like, native 16-bit environment. The legacy 8-bit environment included BASIC in ROM, whereas the native 16-bit environment could only be programmed with a dedicated development environment that wasn't included with the computer. Of course, even many 8-bit Apple II programs were written in assembly language and were locked down to varying degrees (e.g. copy protection, no easy way to break into the BASIC interpreter). But at least that BASIC interpreter was available in the 8-bit environment. So the 16-bit environment represented another step in the direction of separating users from developers.
I remember one experience that, I think, helped spark my interest in programming. One day when I was about 8, my uncle Eric was over at our house, and he brought with him a disk full of 8-bit Apple II games. One of those games was written in BASIC and somehow involved shapes crudely rendered in text mode (I don't remember anything else about the game). He had modified those shapes to bear the names of his kids. That was interesting all by itself. But then, if I remember correctly, he went in and modified the game to show the names of my siblings and me instead. These days, we call this live coding. And with most off-the-shelf software now, it's impossible. If we can fix this for free software, I think more people will be enthusiastic about it. Of course, the specific example I recounted here is pretty trivial, but the lesson is clear: we need to make it practical for people to modify the software they use every day, on the fly, with low friction. Then, the freedom to modify software will matter to more people.
You're right that we can't advocate for just eliminating copyright, without shooting ourselves in the foot. However, eliminating copyright, combined with, say, an obligation of software companies to disclose the source code of their "products" to their customers, or, less intrusively, with making the type of NDAs you describe illegal, would work.
We currently have both a draconian IP regime and woefully inadequate right to repair, but fixing the latter does absolve free software from needing the former to function.
It is a very different strategy than GPL, and doesn't look very likely to happen given the trend in both EU and US, but I see it as a valid long shot strategy. It would be a terrible strategy however if we gave up GPL without anything in return.
In the lambda case, it's very much closer to "build and maintain a house, doing all the trades work yourself" versus just renting somewhere. The latter has a much shorter lead time and upfront cost. If you're just doing a job for 18 months somewhere to see if it works out, would you spend a decade building a house there first?
When our company moved into next office, it had bare walls with old ugly wallpaper. We paid for the new wallpaper, carpet, interior walls, wiring, etc... And we also kept paying the rent to the building owner, and were at their mercy when they eventually decided to stop renting out that space.
Even then, this made perfect sense for business. All-new construction would have been way longer and more expensive, even taking limited lease time in the account. Why would software equivalent of this (Lambda) be different?
With Lambda, it's more like no walls at all... The land just comes with a concrete foundation but you have to build the walls and roof yourself.
A lambda function is nothing more than a standard app with an entry point with two arguments. Your handler function should be “skinny” just like a Controller action in a typical MVC framework.
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.
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).
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.
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.
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.
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/
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.
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.
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.
Kubernetes (Google), Angular (Google), TensorFlow (Google), VSCode (Microsoft), TypeScript (Microsoft), React (Facebook), PyTorch (Facebook), just to name a few.
Its one of the defined software freedoms of the FSF, after all, and its fundamentally why software freedom is advocated for, but it absolutely doesn't need copyright to be enshrined in law.
The widespread love of the Mac and OS X among techies on HN says otherwise.
In cases of catastrophic failure or why-style "digital suicide", it seems like modern tools could easily leave a community with no records at all.
That is not really true.
For one, even users of purely proprietary software do benefit from the work that developers of Free Software do, because the market pressure exerted by their presence in the market does affect the pricing and quality of proprietary offerings. While that is an indirect effect, it does not in any way require "enlisting a developer".
Also, in order to have a free market choice in who you hire to do development work for you, you don't need to enlist a developer. That freedom of choice is every user's immediate freedom.
> The closer it gets to a “pure” user problem, the less incentive there is for developers to work on it, and the worse it gets.
But that has nothing to do with whether it's a "user problem", but only with whether it's a problem of people who value their freedom. If a user values freedom and thus invests in it, such as by paying a developer for doing some work for them, then they will get just as much freedom as developers who value their freedom and for their reason invest in it. The problem is not that they are users, the problem is that they are unwilling to invest in their freedom, and instead expect others to invest for them.
The problem is the expectation that developers invest in the freedom of users. Developers will invest in their own freedom first and foremost, obviously. If you expect developers to invest effort into solving problems of non-developers, you should also expect non-developers to invest in developers solving their own problems. Like, you should expect users to pay developers so they can work on stuff that is of no importance to the user.
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.
Case in point, I recently upgraded the computer of a non-technical person from Ubuntu 18.10 to 19.04. And now desktop icons are completely broken. It's been reimplemented in JS, with horrible performance, and doesn't even support features like dragging an icon to a folder. Their reason for removal? A bunch of technobabble no user would understand. https://gitlab.gnome.org/GNOME/nautilus/issues/158
When stuff gets removed or shut down, the basic reason is that it takes work to keep it going, and someone decides to stop allocating any work to that. Even with client-side software with no service to run (like that mobile app), the platforms they run on change, and it takes work to keep up.
And that's exactly what I see in that GNOME issue you link to. There's a bunch of technical detail about why it's so much work -- but the point they're making is it's been a lot of work to keep that feature going the way it was, and it'd be even more work to continue doing so as the rest of the software on the desktop changes around it in the ways that are planned. And so they decide to drop the existing thing and build a new one in a much easier way.
The only difference from proprietary software is that everyone has the option to step in and say, no, I'm going to go pick up that work, and everyone's welcome to use my version instead. In fact, GNOME makes a great example, because there have been a bunch of popular projects precisely about doing that with previous decisions they've made: https://en.wikipedia.org/wiki/Cinnamon_(software) is one of the bigger ones.
If people had that option with Google Reader, it'd be alive today. (I'm told it was a very small amount of work to keep running, and when the ax fell on it many Googlers pleaded to be allowed to just keep it running on their own time.) Ditto for many of the other proprietary things I've missed after they went away.
Stuff does not get removed from proprietary software installations spontaneously, unless there are automatic updates (which can be turned off).
Stuff spontaneously disappears from a proprietary website, and the users can't do anything about it.
Proprietary websites are a whole new form of social harm that makes plain old proprietary software look virtuous in comparison.
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.
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.
The fact that GNOME is the dominant DE for Linux, despite this fact you cite, really is confounding considering that the whole point of FOSS is supposed to be that it empowers the users. It almost feels like the entire existence and adoption of GNOME by many prominent distros was a conspiracy to prevent FOSS desktops from succeeding.
Of course all that was on the Gtk2/Gnome2 days and Gtk3/Gnome3 broke a lot of bridges, still the complexity of the desktop and the fact that GNOME has actual paid people working on it ended up with the project having a lot of inertia and they are the projects that do most of the work no matter how misguided that work might be.
After all, those who do the work are those who decide how that work will look like. Anyone else, regardless of them being right, wrong, having better or worse opinion on that work, is irrelevant.
If you want to take control of the Linux desktop away from GNOME you need to replace the GNOME stack - not just the desktop, but also the toolkit, the inter-application communication, sound libraries, etc - with something that is objectively better (for a definition of better that a majority agrees with it) and convince other developers to use it.
Yes, but it's not just GNOME who does such work. KDE has been around even longer than Gnome, and has a very different philosophy for their DE (one which, IMO, is much more aligned with the hacker philosophy of being able to customize things to your heart's content and having lots of features), yet most Linux distros stick with Gnome.
>If you want to take control of the Linux desktop away from GNOME you need to replace the GNOME stack - not just the desktop, but also the toolkit, the inter-application communication, sound libraries, etc - with something that is objectively better (for a definition of better that a majority agrees with it) and convince other developers to use it.
Yeah, we already have that; it's called KDE. We also have other DEs based on both Qt and Gtk: LxQt, Cinnamon, MATE, Xfce.
Basically, your post seems to imply that Gnome is the only full-featured DE available for Linux, and this simply isn't the case at all.
To solve that, one needs to find a way to incentivise the developer so they are actually able to work on requests not just features they deem important.
Examples:
Anybody remember the dot-com boom? Sun Microsystem's silly "The Network Is The Computer." ads? No? Linux wasn't even a blip on the radar back then at the enterprise level.
> In a world where Windows was dominant and you had to pay a per cpu licensing fee, would companies be trying to put everything on the web, or would they create more apps that ran locally with some network based syncing?
Um, obviously yes? The fact that Sun and the other UNIX server vendors and Oracle other server software vendors were charging various fees for their OS and software, on a per server or per CPU basis, did nothing to put the brakes on the dotcom boom. Network-centric computing took off well before free software became the buzzword of the mid to late '00s.
True, I'm sure!
Equally true of free software... and indeed when that situation does happen, you're in rather better shape if it's free software than proprietary.
I think there are good reasons for people to keep their software installations generally up to date, though -- certainly anything that's exposed to today's Internet. And for a given version of $component, the OS versions that shipped it will only continue getting updates for so many years. Because of that, in the example I was replying to I don't think it's unreasonable to see an announcement that, strictly, just says "this feature will be dropped from future versions of this software", and think of it for practical purposes as "this feature will be going away".
1. Initially Qt1's license made a lot of developers to shun it (if that was warranted or not is a matter of opinion, but that is what happened).
2. Being written in C++ makes it very hard to not break ABI and Qt broke it several times - either because of itself or because of C++ libraries.
3. C++ also makes it harder to interface with other languages, meaning that for most languages interfaces either do not exist or they do but are of inferior quality. In comparison Gtk+'s gobject was designed to be easy to interface with.
4. Even if you buy into C++, for a long time you had to wrap your build system around Qt with moc and all.
5. Qt was always controlled by a 3rd party company whose interests did not align with KDE's: Trolltech/TQTC wants to provide middleware to developers for developing desktop applications, KDE uses it to provide a platform API. These two overlap a bit, but they also are incompatible in other areas (such as API/ABI stability).
Some of these (e.g. license, moc) are not valid any more, but others (TQTC goals) are and even without them, GNOME has already a lot of inertia.
> Cinnamon, MATE, Xfce.
These desktop environments rely on technology developed primarily for GNOME by GNOME and/or RedHat (and to a lesser extent Canonical) developers, like Gtk+, Clutter, etc.
The original post was about why everyone uses GNOME if other environments are available: if there is anything that my answer implies is that if you rely on GNOME tech and/or tech made primarily with GNOME in mind (even under the disguise of a neutral tech) then GNOME will be where things will work better and first show up.
The only neutral tech that there is on desktop is X11/Xorg and of course the GNOME people want to tear that down and replace it with their own tech.
That's a fallacy of the same sort as party slogans from Nineteen Eighty-Four, just reversed. There they said "Freedom is slavery". What you are saying is "Tyranny is freedom" (since tyrants should be free to oppress). That's simply bunk. Tyranny is not freedom.
Except that it has to cut it in order for a free software movement to exist, because otherwise free software is starved by a chicken-and-egg problem where developers don't use free software because it's inferior, and free software never improves because developers don't use it. In other words, being willing to use technically inferior software solely because of the superior freedoms it grants is the way to make the engine of free software run. GCC was not the best C compiler in the world when Linux started using it.
First, free software doesn't improve "because developers use it". It improves because developers work on it. Blaming the users for that problem is not helping at all, except with a vague sense of moral superiority.
Second, people use tools (e.g. software) to achieve things. "Making the engine of free software run" is not on that list of things for the vast majority of people, so maybe we should try giving them reasons that actually matter to them.
Third, the reason that GCC was used for Linux was that it was the only one that was widely available, free, and had a 386 backend that produced useful code. Nobody involved gave a bit about "engines of free software" and "superior freedom", it was the only tool to get the job done.
It was certainly not technically inferior at the time.
Fourth, a large part of the reason for commercial software usage is the incredibly sanctimonious community around OSS.
If I can buy a piece of software that does exactly what I need, in a pleasant way, for a small amount of money, potentially even with support that cares about me? Why ON EARTH would I sink tons of time into a craptastic piece of software with horrible UI and an abusive community?
Like it or not, OSS is competing in a marketplace. It doesn't need to win on all axes, but it needs to win on some outside of "free"
Secondly, nobody is suggesting that free software should not try to compete on non-philosophical terms. What people are suggesting is that a volunteer project cannot perpetually out-compete a well-funded proprietary competitor. If people care about the continued existence of free software, then they will at times have to console themselves with using software that, while hopefully fit for purpose, is quite possibly not best-in-class.
Most servers run Linux and Apache or nginx. The most popular CMS is WordPress. MySQL, PostgreSQL, SQLite, Redis, and MongoDB are the most popular databases.
On macOS, the most common shell is bash, and most of the commands are free. According to the 2019 Stack Overflow developer survey, two of the three most popular development environments are the open-source Visual Studio Code and Notepad++. The most popular web browser was Firefox for a while, but even Chrome is based on a ton of open-source technologies.
Most people aren't picking these tools because they have some principled stance on free software, they're picking them because they're just plain better.
Turns out data roach motelling is a big thing. And it's even better for the corp interests if they can tie hardware and software to irreplaceable APIs that lock the user down to the whims of the owner.
It's time to take the fight back to "Owner"... If you purchased it, why can't you do what you want? Why are you prevented from doing arbitrary actions?
The leadership of the Mozilla corporation is pathetic, toothless, and either useless or ill-intentioned. This is a comment and I'm not trying to convince you of these things, I'm stating my opinion. Readers of this comment should feel free to look at the decisions taken by those people these past years and agree or disagree with me.
Closed source in the legal sense, I guess, but there's nothing stopping you from popping a devtools inspector inside of Discord and reading through everything. It is an Electron app after all.
So I had an android IRC app for a bit, some top paid one, and get booted from a bunch of my favorite channels because apparently it was just sat in my pocket cycling my connection and flooding the channel with join/unjoins.
That, plus the weird way to authenticate doing /msg Nickserv identify. That might be just how the server I was connecting to was implemented, but it felt fucky.
IRC was designed, mostly, for two types of users: A) Large institution users who had a fixed link to the internet and ran in their shell on a mainframe. B) Dial-in users, who's devices mostly stayed connected, and when they disconnected, usually required manual intervention to get back on.
Anyone, and I mean ANYONE using a mobile phone SHOULD be using a 'bouncer' or other gateway to access a live communications environment. This would be more like use case A where someone has a small agent on a slice of a server they 'trust' and that maintains state (for their client) and stateful connection (for links to other servers and users).
IIRC, Quassel IRC has such a client/server model for the client, there are probably others too.
That's what SASL has been for for over a decade nowadays :)
The goal is to get rid of the historic interfaces which required a lot of RTFM, and instead to allow users to discover functionality through the UI easily.
If you have any suggestions on what to improve regarding UX of Quasseldroid (my main project), I'd love to hear suggestions, as I'm always interested in improving its UX and learning more about UX design. After all, I, as quasseldroid maintainer, am just one student, not a team of highly paid UX designers.
(And personally, I'm a huge fan of tools like Zulip, Mattermost and Matrix as well — we're all fighting on the same side, after all :)
https://rocket.chat/
https://zulipchat.com/
https://matrix.org/
https://mattermost.com/And I'm personally working on Quasseldroid, improving its UI to make it much more usable.
If you have suggestions on how to make Quasseldroid usable for the people that refuse to use IRC, I'd love to hear them :)
I've used IRC quite a bit but Slack is light years beyond in terms of the UX of even the nicest IRC clients. I think Discord is probably even better than Slack though.
If you think that you can't do free software development without relying on all the capabilities of Slack, then the honest thing to do is to quit and spend the rest of your days just working on proprietary stuff. You obviously prefer the solution which has features over any other concern, so why would you waste your time having anything to do with free software?
Richard Stallman obviously used proprietary software. But not past the point when he had replace it, even imperfectly: "I began work on GNU Emacs in September 1984, and in early 1985 it was beginning to be usable. This enabled me to begin using Unix systems to do editing; having no interest in learning to use vi or ed, I had done my editing on other kinds of machines until then." [https://www.gnu.org/philosophy/fsfs/rms-essays.pdf] This tells us that Stallman used Unix. Well, why wouldn't he have; what other practical way was there to code anything? (One supposes he could have started from the bootloader on up, like the Unix guys before him.)
Stallman wouldn't use Unix today, since it has been replaced by free software, and he wouldn't use arguments like, well, such and such proprietary Unix has better memory management or faster I/O, so I will still use that.
If you're using things like Slack or Github without the slightest intent of working toward replacing them, yet using them for free software activities, then that is a comically conflicted position.
And personally I consider the slack UI, especially due to the different workspaces, relatively unintuitive.
I don't see a big difference between sending the message :rose: in Slack and having the client display it as a picture of a rose, vs sending the message :rose: in IRC and having the client display it as a picture of a rose. Emoji don't enter into it.
Reactions, maybe.
Sure, but the reason all the developers at my workplace use Slack is because we have to communicate with a lot of people who aren't developers.
Slack's good UX extends beyond the basic chat interface to configuration, administration, and initial signup. It's significantly easier for someone nontechnical to toss money at Slack to get a new private space than it is with IRC. The first page of "IRC hosting" search results on Google for me are mostly shell accounts; nothing turnkey and professional looking that a business person could/would use.
And honestly, of all the alternatives, IRC is by far the most popular one (and the other alternatives have IRC bridges) hence the most likely to stay around the longest.
Also the simplest to implement, which helps a lot too.
Otherwise, for instance, nobody would be debugging with gdb, rather than Visual Studio or what have you.Nobody would be LaTeXing instead of using MS Word or Adobe Illustrator.
GIMP isn't as good as Photoshop (if I believe what people say), yet people still use it. (I've only ever used GIMP since 1996; I have no idea about Photoshop and don't care; it's not free, won't use it.)
People went through all sorts of inconveniences to use free software, like manually figuring out monitor clock timings to stick into their X configuration, building their own custom kernels and whatnot.
You can't say "convenience wins" with a straight face; that's like saying free software doesn't exist.
Hahaha. Have you tried to write a piece of mathematics in MS Word? I did. It's a torture I wouldn't wish on anyone I know.
Mathematicians are all about convenience; so much so that proprietary LaTeX Editors were quite popular before FOSS caught up (remember WinEdt?).
But LaTeX itself - it's the most convenient tool to write and share mathematics that's ever been made. It's unsurpassed. It's required if you want to publish, because all the journals use LaTeX, and most math books are made with LaTeX.
It's so good that people will literally think you are an idiot if you are not using it[1] and won't believe your results.
And ArXiV, have you heard of ArXiV? No LaTeX, no ArXiV.
And trust me, most mathematicians don't care much about FOSS. But they care about not spending too much effort on making their results presentable and shareable. LaTeX -> PDF is the path of least resistance.
If you're working with embedded Linux, Visual Studio isn't going to be much help for debugging on a target.
>Nobody would be LaTeXing instead of using MS Word or Adobe Illustrator.
LaTeX does some things much better than Word, and Illustrator is very expensive.
>GIMP isn't as good as Photoshop (if I believe what people say), yet people still use it.
GIMP is free. Photoshop is not.
You seem to be assuming the people have unlimited money to purchase software licenses. Many free software programs are used not because they're better, but just because they're free and good enough. If I just want to crop and rescale some photos or something, why on earth would I buy a Photoshop license when I can just download and use GIMP for free?
Some Windows users use neither GIMP nor Photoshop to crop an image, but rather MS Paint, which is comes with the OS, so it is "no additional cost", and requires next to no training to use.
MS Paint has vastly diminished functionality compared to either GIMP or Photoshop.
If Visual Studio ran on Linux, would anybody bother with gdb? Currently, the second-highest voted UserVoice issue for Visual Studio is people asking for a Linux version (and rather hilariously not understanding what a colossal rewrite that would entail...)
https://visualstudio.uservoice.com/forums/121579-visual-stud...
> Nobody would be LaTeXing instead of using MS Word or Adobe Illustrator.
LaTeX might just be easier than trying to typeset something reliably in Word. I know I always wrote in plain-text and then did a final pass to paste and format it into Word immediately before printing.
> GIMP isn't as good as Photoshop (if I believe what people say), yet people still use it.
Photoshop is stupidly expensive still, and cracking software has fallen out of favor
How many of these users are long time free software developers, though, who did free software long before it could just be a reluctant aspect of a job you land into?
That's hardly the case; they are not even aware of the existence of alternatives.
Most of people's occasional image fix-up needs could be met just by MS Paint, which they would find easier to use. Problem is, they don't even know that exists and that they have it pre-installed, let alone that GIMP exists.
I mean, I debug with lldb which is free and open. Sure, I do the debugging through the non-free(-as-in-freedom), non-open Xcode, but that's because Xcode lets me harness the power of lldb in a manner that suits me.
There's nothing stopping free and open software projects from being delivered in a user-friendly manner. I'm sure there are plenty of people using gdb and lldb with fully-free and fully-open editors and IDEs.
Sometimes it just takes a mindset adjustment to see that what is most often considered inconvenient, and that followers of free software doctrines must begrudgingly accept as their lot, can actually be delivered in a user-friendly manner that meets the proprietary-software-users' expectations.
I don't want to use an IDE, I want to debug a Java program. I don't want to use video editor, I want to have a video. I don't want to use 3D redactor, I want a 3D print something.
I can go on forever. The problem with lots of free software folks and linux crowd is fetish of tools. Tools for the sake of tools. I couldn't care less about tools, I want to achieve something, I'll pick up whatever tool that allows me to achieve that quickly and effortlessly. And I'm telling you this as someone who's using linux and writing a bookmark manager for myself in Go right now to pair with menu because all other ways of doing bookmark management suck.
%s/redactor/editor
Separate question why would it do that
Yes, but convenience also leads to greedy "algorithms" prone to getting stuck in local maxima. Convenience can make us lazy and choose the wrong long-term solutions.
This applies to more things than just tech ("convenience" may make us choose foods that are wrong for our health, for example).
Not at all. There are million examples of human society choosing long term and social benefits over short term and personal rewards.
There are trade-offs. OSS can shift trade-offs on some of the axes, but that's about a cultural change.
It means giving up on the ludicrous idea that GitHub is bad because it "runs proprietary JavaScript executed in our browsers". It means realizing that "writing code" is a tiny part of creating a useful product. It means giving up on the disdain for all things non-engineering. It means welcoming people into the community who "just" want to write documentation, or work on UX, or any number of other things. It means letting go of overblown rhetoric like "we're the resistance now".
Above all, it's about realizing that it's not about "choosing a fight", but creating a better community.
(I actually think Linus is a positive figure overall, I just really can't stand git's UI)
It occurs to me that if IRC networks hosted their own bouncers, but that these bouncers were written efficiently to exchange data directly with the IRC servers' and their database rather than keep individual logs and so on, we might have something close to the "open-the-app-and-see-past-messages-without-needing-to-be-permanently-connected" quality that people have come to expect from instant messengers, Slack, Discord, etc.
(but then you might as well just write such functionality directly into the IRCd)
Nah, such a thing would make most sense as a separate daemon that uses the server-server protocol to connect to the ircd (ie. it appears to the rest of the network as just another ircd).
It wouldn't be hard to build such a thing, the hard part would be convincing an existing IRC network to run it.
Even PeaZip has a (slightly) better UI than 7zip (and that one is also crossplatform, if you care about that stuff).
The reason I use it is because it's open source and there are no terrible nag screens.
* We are not rolling our own. Whether we host it ourselves or pay for a service, we’re getting something off the shelf that best meets our needs.
* We are evaluating products, not protocols.
* We aren’t picking an outlier; whatever stack we choose needs to be a modern, proven service that seems to have a solid provenance and a good life ahead of it. We’re not moving from one idiosyncratic outlier stack to another idiosyncratic outlier stack.
Given other language such as "modern expectations" in regard to interfaces and being "spoiled for good options" as well as Rust's move to Discord possibly setting a precedent within Mozilla, the posters in the HN thread above don't have a lot of hope Matrix will be selected even via Riot.
One example, which for me is one of the most annoying aspects of using 7zip, is double clicking on an .exe file or .html file or anything in an archive that relies on other files in the archive (dlls, images, data files, whatever): 7zip extracts only the file i double clicked on, ignoring everything else whereas WinRAR extracts all files since chances are if an executable is part of an archive, it'll need the other files in the archive to work too. This means that with 7zip i have to manually unzip the archive somewhere first, usually drag and dropping the top folder in the archive (assuming it has one, many donts) in the desktop or a temp folder, then open that temp folder, run it and then delete the folder. With WinRAR i just double click the executable and WinRAR does the rest. This is very useful when i want to run some game from a gamejam, run an installer which for whatever reason isn't part of an executable, test an archived build of a project that is made up of exe+data, check an archived webpage that is made up of several html and image files, etc.
As a sidenote (and another source of frustration), 7zip also has the annoying behavior of deleting that temp file almost right after it extracts it (i'm not sure exactly how it decides that) which means that unless the associated program is fast enough to open it, it'll get deleted under its feet, creating a race condition between the associated program and 7zip.
There are other issues with 7zip as well as a lack of features (practically zero features in the self-extracting archive generator, as an example). The main reason i have it installed is because it can open more formats than WinRAR, especially useful when dealing with disk images from VirtualBox since i can simply open it with 7zip and extract files from there directly without booting the VM. But when it comes to working with zip, rar and even 7z archives, i stick with WinRAR.
BTW, the "terrible nag screens" go away from WinRAR once you buy it. It has been a while since i saw any of those.
Matrix is an incredibly centralized service masquerading as an easily self-hosted distributed service. The moment you try to get a non-technical user connected to a homeserver other than matrix.org, all hell starts to break loose.
It's bad enough that both France (tchap) and Purism have created their own client forks to make on-boarding somewhat tolerable at the expense of really painful rebases against upstream Riot, while Riot tries to get it's shit together on the non-matrix.org user story.
Mattermost has a slightly less painful situation -- they provide a relatively easy to brand/preconfigure client (and fantastic docs on how to do so: https://docs.mattermost.com/mobile/mobile-compile-yourself.h... ), but you lose out on federation and self-service sign-up, leaving your community isolated (sometimes a pro, sometimes a con).
I've personally run 3 homeservers for communities formerly centered around Facebook, only one of which was technical. For the non-technical communities the workflow was the one provided by riot-web when a mobile user visits the homeserver.
Neither of the non-technical communities saw more than 5% adoption in the org. The technical community constantly complained about the login flow.
When I deployed Mattermost with a custom app for the first non-technical community I saw 40% adoption within a week, and 80 within the month. The second community has looked at the first as an example, and I can expect 80%+ adoption within a week or two of deployment.
I've asked repeatedly in both #ios:matrix.org and #android:matrix.org about assistance in putting together docs similar to mattermost's and was completely ignored.
I've asked if the Riot folks would be open to deep-links providing the homeserver to mobile apps, and was shut down by somebody who insisted deferred deep links were the only kind of deep links, and that they would only ever be supported by a Google Play on-boarding flow.
I really want to love Matrix, but y'all make it fucking difficult sometimes.
Edit:
I'm speaking from the perspective of an upper 20something. I'm part of a generation that jumps jobs when the opportunity is better, or just because "it's been too long", not the one of years past where I'd be expected to work my way through the same company my entire life. With that said: if my new job says "we use Slack" then I use Slack, end of story. If they say "we use IRC" then I'd Google for how to use IRC because I have never ever used it in my entire life, never read up anything about it in my entire life, and I definitely don't hold IRC in high reverence like many posters here do. All I can see when I google IRC is that it looks ugly and honestly, that's what's most important to me these days because I have to look at, and interact with, the thing for 8+ hours a day so the least it could do is work out of the box, look modern, and doesn't need me to waste hours fussing with some dotfiles to get it to look the way I want, which is exactly how most modern chatting apps look (again: to me it's a waste of time, when I can just grab a off the shelf solution).
I appreciate that there is open source, and that there are free programs out there. I appreciate all the libraries that make my life easier. But the thing is, these are all tools I use to do a job. I don't care at all about the history of say gcc. All I care is that it works and compiles my programs, and if it does, then so be it. And if it doesn't? There are other options, icc, llvm, etc. My point is that at the end of the day, all I want is a tool to achieve a solution, and who makes that tool, or the history behind that tool, doesn't matter to me at all. It's not even part of the equation.
When the "new" tool is worse than the "old" tool, i care (and yes, the "new" tool can be worse - and often is - yet displace the "old" one, not because of its quality, but because of external reasons - like the developers of the "old" tool being unable to sustain its development).
Have you done a full migration of a grown Wordpress blog to another system, without breaking stuff? It's not something you do on a weekend or two. Changing away from a tool that holds lots of data and configuration is expensive.
Proprietary software that is years past its support date, from a company that has not existed in years, yet still in use, is also a thing.
The one kind of entity that dies instantly when its backing goes away is a proprietary website.
Being technically the best (or the best in 'freedom') doesn't seem relevant to anyone.
IP, TCP, SMTP, HTTP, these are fundamentally technologies of federation. They succeeded and continue to succeed spectacularly. However, with the commercialization of the Internet there are much stronger countercurrents. I still expect federated solutions to succeed, but adoption will be slower and punctuated, and in the interim there'll be countless proprietary also rans.
I think you can see some evidence of what people thought were development machines by the fact that Lisp Machines only seem to have been NFS servers, not NFS clients.
I totally get the value of a non-corporate, non-centralized solution. It just needs to have at least as good of a UX for me to switch back to using it.
https://www.gnu.org/philosophy/open-source-misses-the-point....
> A pure open source enthusiast, one that is not at all influenced by the ideals of free software, will say, “I am surprised you were able to make the program work so well without using our development model, but you did. How can I get a copy?” This attitude will reward schemes that take away our freedom, leading to its loss.
> The free software activist will say, “Your program is very attractive, but I value my freedom more. So I reject your program. I will get my work done some other way, and support a project to develop a free replacement.” If we value our freedom, we can act to maintain and defend it.
Relying on Slack, Github and what have you is clearly not to "get my work done some other way, and support a project to develop a free replacement.” It aligns with attitude exemplified by the "pure open source enthusiast".
Meanwhile, if you go to Riot/Web on mobile for a custom deployment, you should see a page like this https://webchat.kde.org/mobile_guide/ which guides you through the process.
Deeplinking from web into the app is hard, as the only way to do so vaguely reliably is by fingerprinting the browser using something like branch.io, which is distasteful from a privacy perspective. Meanwhile, affiliate links in google play seem to only work about 30% of the time, given the planets have to be in precisely the right orientation for the association to not get lost.
Mattermost might be doing something smarter (perhaps letting you install the app generically, and then getting you to click a custom URI handler link from the web to provision the correct config on the client?) - but would be useful to know which of these failure modes people were falling into?
This is exactly whay I was getting at before. Please stop fixating on the deferred form of deep links. The play store need not even be involved for deep linking to an already installed app.
The mobile_guide instructions are where most people bail out.
"Yeah, no. This is too complicated." is the response when they see
"Install an app, then click on a check box that changes the UI, then enter https://foo.bar:8448, then register".
That's a massive turn off before your app is even installed. A flow of "Install this app, then return to this web page" is significantly easier. Or if/when branded builds of Riot are possible, it becomes "Install this app."