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.
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.
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.
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.
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.
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.
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.
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.
- 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.
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.
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...
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.
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.
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.