Philosophy of the GNU Project (2018)
gnu.org
gnu.org
We are living in a world where corporations control nearly everything by building proprietary systems. They have more than resources to buy, lobby, manipulate, seem "attractive".
We need more of this kind of organization, free society cannot exist without free software.
Maybe you're confusing the free time that developers have because of their corporate jobs to create FOSS, but this is not the same as directly writing and paying for FOSS by corporations.
This gets complicated because are you talking about volume of code created or are you weighing code by its use? Anyway, you might be right, I don't know, but my assumption is that FOSS is mostly developed in spite of lack of corporate resources, not because of it.
Massive companies everywhere have thousands and thousands of people collectively working all day on free software as their main job.
You’re probably using a free software browser from a corporation right now?
Free (as in 'free beer') is not the same as FOSS.
Who said it was?
Chrome, Safari, Firefox are all primarily FOSS - they have some proprietary trademark and minor components, but the actual browser core in each is FOSS.
https://policies.google.com/terms
https://www.apple.com/legal/internet-services/terms/site.htm...
Maybe there's some code that at one point was FOSS in those products, but the products themselves are nor Free.
IMHO a code base that has been forked from a FOSS project cannot be considered FOSS itself even if they keep retrofitting changes back to the original, because you cannot know what is there in the proprietary part. This is specially true if you distribute the derivative product only in binary form.
But you're also wrong.
The trademarked Chrome distribution is built from the free Chromium, where main-line development is done. They don't dump changes over the wall like you're suggesting. That's the same for WebKit and Firefox.
BSD and MIT licenses are Open Source but not Free, they are more concerned with providing a claim of ownership to the author than with the freedom of the user.
LGPL is a backdoor to let Free Software interact with non Free Software, which is a good thing too. If your product uses Free Libraries, no big deal, the more the merrier. But you cannot claim it is also Free y proxy.
Look at threads you've commented in in your browser's incognito mode to see how your comments are invisible (Not this one, I've vouched for you which makes them visible, and some others have been vouched for.)
Your comments have been hidden by default to all users except those that chose to view them like me since September 2017. That's why so few people reply to you. You've been talking into a void. Don't know what you did back then to piss someone off!
Crazy isn't it?
We also have to be careful about what we define as a 'corporation'. You're clearly putting non-profits under that category and that may be fair, I don't know, but for non-profit corporations that have a large portion of their income in the form of donations or have been created with the specific charter of promoting, developing or maintaining FOSS, it seems pretty disingenuous to lump them into the same 'corporate' category. It gets further complicated if you consider colleges and universities as corporations.
Here are some links that may help move the discussion, though they don't answer the question head on (as far as I can tell):
* https://www.quora.com/Has-anyone-ever-tried-to-estimate-the-...
* https://www.linux.com/news/study-open-source-worth-387-billi...
* https://octoverse.github.com/2016/
* https://thenewstack.io/week-numbers-data-lots
* https://www.techrepublic.com/article/who-contributes-most-to...
* https://redmonk.com/dberkholz/2013/04/22/the-size-of-open-so...
* https://www.techrepublic.com/article/for-50-percent-of-devel...
Some estimates put the Linux kernel at around $300B+. The above links measure contributions from various companies, of which Microsoft (who now owns GitHub) and Mozilla make the top 10. There needs to be some work done to figure out the actual answer the question ("do corporations fund/create the majority of FOSS?"), including figuring out what aspects of the question are actually valid, like whether it's code used or code created, what counts as a 'corporation' etc.
Like I said, I don't actually know but this is something that I had a bias towards believing that FOSS excelled in spite of corporate backing instead of because of it.
I'll say it again: citation needed.
A rather better term would be FLOSS [1]
You’re probably using a corporate free software browser right now?
The idea that free software is a niche done by amateurs is wrong. Most people who work on Linux are paid to do so. Same for Chrome, same for Java, same for LLVM, etc etc all the way up the stack.
Free software won, and we have the corporations who funded it to thank.
If the majority were paid, GIMP would be on par with Photoshop, Inkscape with Illustrator, etc. But they’re not on par because they don’t have corporations throwing millions of dollars at them like Adobe does.
It’s just not the case that most projects are just random hobbies these days, and it’s bad for the movement to keep pretending it is. It’s grown up and corporations invested - that’s a good thing!
I guess we’re just arguing past each other. I agree it’s good to recognize money in the industry (many have an aversion to it because of EEE fears), and I also agree that the majority of successful projects are done by paid people. I guess that’s the disconnect: I’m looking at all projects, not just the successful ones.
https://en.wikipedia.org/wiki/Embrace,_extend,_and_extinguis...
Taking money does not lead to EEE unless you're taking it for the explicit purpose of making incompatible software. (A person with anti-competitive attitudes doesn't actually need to take money to do this, but it probably helps) The aversion to money is likely coming from somewhere else.
Money thrown by corporations is what separates successful projects, like Linux, or Apache Spark, or Postgres from niche things that no one knows or care about.
Another common scenario is big corpo developing software for internal use, and then open sourcing it, so that volunteers can do maintenance (e.g. Kubernetes)
* Niche done by amateurs * Corporate funded development * People not being paid to work on free software but contributing to free software because it benefits the company they work for.
I fall into the third camp. The company I work for would never send me to FOSDEM and don't pay me to work on OSS but they recognise that me doing so benefits them.
This was a schism back in the 90s and open source won out in the long term and free software philosophy is still niche.
Again, this does not "matter" in practice for developers day-to-day as the actual software labeled as open source or free software is essentially the same set of software and same set of licenses (with differences only relevant for nitpickers).
But the whole free software movement is a strongly political and ethically motivated one, considering proprietary software an injustice, power abuse, immoral. Not just a worse model of cooperation or engineering practice. And as I wrote elsewhere in the thread, most devs have no idea about this fact, not to mention having a stance or opinion on it.
The companies that make the hardware should fund the software.
The ethical-philosophical free software people are terrible at marketing and getting their message across.
It's still just a small niche subculture despite the wide adoption of GNU tools and licenses. You'll never reach further with all the silly in joke stuff like Chief GNUisance etc. You'd need charismatic frontline personalities (there's a wide spectrum to explore between RMS and sleazy snake oil salesmen), who don't immediately put off the general population.
And I'm OK that some Free Software actually let do that, but the thought that those who don't are somehow bad or a threat to the general concept of "freedom" is... weird. (Like there is a single perfectly defined concensus on the concept of freedom anyway)
You are confusing respecting people differences (e.g. neurodiversity, ethnicity, religion, nationality, orientation and so on) with accepting any behavior with choosing the right person for a given role.
This are 3 different things.
This is mostly seemed to escape our notion. Perhaps one must die in order to be understood or recognize.
Or perhaps we need to look at things which happened a long time ago (history) to fully grasp their importance.
source: software developer late 1980s California, in the room with some of these people including Stallman in Palo Alto, discussing and presenting on this topic
People still believe this myth? 30 years on and still sour grapes from the BSD folk who were too slow and to elitist to adapt.
I think that making the very forces of copyright and profit-seeking work successfully for the benefit of free, universally available software is a feat of rare ingenuity and understanding how humans think and act.
Case and point: http://alexeymk.com/dear-dr-stallman-the-aftermath/
I'm not sure what do you mean here. I was a totally average computer user when I found Stallman's writings (especially, "The Right to Read", and the story of the printer drivers) extremely seductive and compelling. A big part of me being genuinely interested in computers is thanks to him (and also to my father, who tried in vain to teach me to draw the mandelbrot set in gwbasic).
Honestly, has anyone ever been "alienated" by RMS? He's a very good communicator and makes funny talks with a deep message. In all venues that I have seen in person, he attracted a huge crowd that did not fit in whatever auditorium was reserved for the talk.
The top article on https://www.gnu.org/philosophy/latest-articles.html links to a 2019 article (https://www.gnu.org/philosophy/free-software-rocket.html → https://www.theverge.com/2019/6/18/18683455/nasa-space-angel...).
If I sell you my software with a "free as in freedom" license, you're now free to give it away yourself.
So "free as in freedom" does also mean "free as in it costs you nothing" for everyone except the first customer.
To be clear, I LOVE free software. I just also think it's more honest to say it's free in every sense of the word. This debate about "free as in free beer" versus "free as in freedom" is pedantic.
Pragmatically speaking, I can't give you full freedom to modify and distribute my software without immediately reducing the market value of that software to zero. They go hand in hand.
(Does that mean there are no business models for free software? Of course not. There are many proven ones, such as paid hosting of it, paid support and maintenance, paid customizations, etc. But the code itself is free in every sense of the word once you've granted that license to the first buyer.)
I agree with you that it seems impossible to have free as in speech software that isn't also free as in beer, but you can have free as in beer software that's a gateway to vendor lock-in, for example.
If that was the only point GNU was trying to make, I'd be in full support.
But that doesn't seem to be their only point. As I read it, they're arguing that freedom-of-speech does not imply freedom-from-cost. And I think that's nonsense (again, after the first sale).
Am I wrong to read their philosophy this way?
I want the free-as-in-freedom since if the vendor goes under, I can pick up the pieces myself. If my vendor goes Oracle and decides to milk me, I can find an alternative supplier.
I don't want free-as-in-beer because I'd rather pay a vendor $10 or $50 per month or something than pay my IT staff $100 or $200 per hour.
I'd also rather pay the original author $50 per month than pay an off-brand hosting company $25 per month because (1) I'll get better support (2) I'm not a douchebag.
As you say, "I'm not a douchebag" implies there's some kind of karma involved; when MySQL "went Oracle," the free-as-in-freedom choice of the developers was to start MariaDB and many in the community interpreted this as the developers' way of saying "I'm not a douchebag."
Oracle kind of has a reputation.
So in essence, if someone pays me when they were free to pay the off-brand hosting company, then it is a strong positive signal. Companies that Oracle-lock their customers are trading long-term profitability for revenue this quarter, as their savvy customers will immediately begin looking elsewhere for a competitor.
Basically if I grant you, the user, the freedom not to pay me, I can trust the signal that those who do pay me want more of my product.
Economies are all about signalling.
* My IT guy $200 per hour. If maintaining a technology takes a day a month -- which is wildly optimistic -- that's $1600 per month
* The organization which developed the tool e.g. $50-$200 per month
* A random outsourcing organization $10-$50 per month
By making your software free software, I will still pay you, but I know that:
1. If you do decide to spike prices, I can go to the off-brand company or to my IT guy. You better provide better service than the off-brand at lower prices than my IT guy.
2. If you do go out of business, I can go to my IT guy.
It's all about power dynamics. You don't have the option to f- me, and by having taken away that option, you've made it more likely I'll buy from you. It's often just simple good business.
Oracle's business model is largely about buying up companies with large locked-in entrenched bases, spiking prices while lowering costs, and milking cash cows as the cows gradually die. They did that to Java and a few others. Free software means I can't get Oracled too badly.
Some companies take a middle ground by e.g using open APIs. For example, AWS has services which have better price/performance than free software, but maintain compatibility. I'll be more likely to use those than proprietary alternatives because if AWS decided to Oracle me, I can switch to the free software version. There are systems like git, where essential business value is free software, so I can move my code out and around if Microsoft decides to oracle me, but where there is a significant proprietary value-add.
Your value to customer goes up with:
100% free > hybrid models > proprietary
Your barriers to competitors go the other way.
This isn't just signaling. It's power dynamics. Companies send out false signals all the time. This is a hard barrier.
The right business model depends on your market and technology. I've mostly done free software, and that's mostly a matter of choice -- I've picked businesses where 100% free makes business sense.
In other words, I'm signalling that the power-dynamics players end up costing too much.
I used to do business-on-a-handshake too. Nowadays, I don't try to "lock [customers] in with contracts," but I do "spend a lot of time carefully studying everything" to make sure things are guaranteed fair to both sides. I'd advise the same, but until you've been down that road once or twice, I suspect you're right that we might not get along. I was there too at one point.
The business-on-a-handshake crowd is a mixture of honest people and con artists. I was told by more seasoned mentors that good contracts make good partnerships, and now I believe that philosophy.
Richard Stallman used to make that much consulting on GCC for clients -- in 1980s/early 90s dollars. His commitment to software freedom did not compel him to wear sackcloth and live as a pauper.
He's also got the MacArthur back when a megabuck was real money.
The way RMS wrote of the event, I had the impression he felt shocked and betrayed. That was the inciting incident.
I think his current lifestyle was motivated in part by huffing his own farts (figuratively speaking) and believing his own hype. He thinks he's the free software prophet he's been cast as by admirers, and is deliberately renouncing the ways of the world, much as prophets did in times of old, and hippies do to the present day.
I'm not arguing against the various business models that surround free software, such as vendor support contracts.
I'm arguing that GNU seems uncomfortable with what seems to me to be a self-evident truth: As soon as I grant you the freedom to use my software in whatever way you like, including for distribution, that software is effectively free-in-price moving forward.
And that's not a bad thing! What I DO think is bad is going to great lengths to avoid accepting that truth, or to avoid talking about it.
Free software is free in every sense of the word, no matter what GNU wants to believe.
They aren’t trying to teach me as much as they are trying to persuade me.
This ends up resulting in awkward doublespeak as you described.
I love GNU and truly want it to survive and prosper into the future. I feel like the younger audience is too aware of these tricks and the technique at this point does more harm than good. Instead or persuasion, it is losing trust. Which is sad because of all the organizations in tech(when you include for-profit companies) GNU is one of the organizations I can trust the most to act in my best interests.
One problem with this would be ongoing software maintenance. This could be great to launch a new piece of software; how do you fund the maintenance?
There's a lot of ways to make money around free software.
But pretending that you can maintain the price of the software itself after you've given every buyer the right to sell or give it away for free is silly. It's not silly to give it away. It's not silly to sell it once and accept that it's not free. But it IS silly to pretend that's not what you're doing.
You haven't offered any counterargument to that.
You've stumbled upon one of the many benefits and consequences of free as in freedom. It should be obvious that the market value of anything free as in freedom will be zero. If you're an American citizen, I'll sell you freedom from government censorship for $5.
My point was that "free as in freedom" implies free as in price. That's literally what I said.
I do acknowledge that I appear to be in disagreement with many people about what GNU's point is when they insist "it's not about price".
To me, "it's not about price" means you're trying to say that price has nothing to do with freedom.
For others, "it's not about price" simply means that's not the focus, or not the only point, or not the main point. Which is a fair and perhaps more accurate understanding of GNU's point.
I could very well be mistaken about GNU's intent. Judging by the amount of downvotes I'm getting, I'm clearly in a minority. But I remain unconvinced.
It's not the only thing it's about. But it's definitely a big part of it.
Compare and contrast with using a service like google. Not only do you have 0 idea about the algorithm they use, your data is extracted for their benefit. You don't even know what data they have on you, and how this is used!
I know you can takeout info from them about your profile, but let's be honest, what use is that to you then?
Proprietary software, which I agree often contains user hostile elements, also tends to have vastly superior polish and user experience. UI/UX is often the majority of the work required to make good software. Making the software function usually takes a lot less time and effort than making it usable.
UI/UX and other aspects of software usability are also often the more boring and grinding aspects of software development. This stuff is not fun, so people have to be paid to do it.
But “you can sell free software.” That is true. But by this philosophy software cannot restrict the rights of others to sell it too or it is nonfree. In practice that means third parties who did not write the software but have more money or more time to invest in polish and marketing (because they are not writing the software!) are the ones to profit and they usually give nothing back to the original authors.
GitHub didn’t write git. AWS didn’t write Postgres. But they are the ones to profit. They took someone else’s work and marketed it well, or SaaSified it. The original authors get nothing.
The original idea of free software was a mutual gift culture where everyone builds and everyone uses. Today it’s a take culture where a few people build, others polish and monetize and give nothing back, and most people use the monetized version because time is more expensive than money and nobody has time to DIY.
The vast majority of people must make a living. So that means free software is only for people with trust funds?
This also implies that there will be almost no usable free software, so freedom is only for nerds. The general public gets proprietary malware that spies on them and locks them in, because that is where all the money is by design. There is no money in giving people freedom.
I am simply pointing out that your nice utopian ideals are helping create a dystopia. That was not intended, but results matter more than intentions.
Again, orthogonal to the philosophy.
A more interesting question is how it is then possible to create free software on the scale that is nowadays expected.
The current model doesn't work... unless you only want freedom for nerds and the independently wealthy.
Edit: wanted to throw in one more point on usability:
Lets say my time is billed at about $50/month, which is low for a software engineer. Now lets say a Linux desktop/laptop requires 5 hours of system admin time per month to troubleshoot drivers, upgrades, etc. That means a Linux desktop/laptop costs $250/month. For that price I could buy a new Mac every 10-12 months. I have a Mac right now and spend less than 30 minutes per month futzing around with it, so it's far cheaper.
A lot of the people who don't get this are young people who are middle class or above (in the developed world) and who therefore have an abundance of free time. Telling busier, poorer, or older people with families they should set up their own servers or run their own Linux systems is sort of a "why do they not eat cake?" attitude.
This neglects the structural profession elitism here-- that only people who know how to admin Unix-type systems should have freedom or privacy.
I believe these different ideologies can coexist. You can call me "nerds or people who don't have the work," I'll keep writing the free software and making the money.
I'm also free to continue to promote my ideology. No need for name calling.
Do you have a proposal to address these issues? I ask because I see that you're not happy with things as they are, but I'm not sure what GNU can do to address your concerns.
Or you can just buy from a GNU and/or Linux vendor that supports their own hardware and distro and get the same benefits. (System76, Purism, etc)
>Telling busier, poorer, or older people with families they should set up their own servers or run their own Linux systems is sort of a "why do they not eat cake?" attitude.
Why? When it comes to servers the actual alternative there is either telling them to buy a Windows server, or start paying cloud providers, neither of which really have a lower money/time investment in all cases when you get into it. This is assuming that the reason someone wants to have their own server is to have a home business. (And if you're on the cloud there's a good chance you'll end up running Linux there anyway)
You (and the other replies) are missing the main point of reciprocal/protective licenses like GPL:
To pass down freedom (including freedom FROM surveillance) to end users. Avoid lock-in and "tivoization".
You are probably thinking about weak/non-protective licenses. They are commonly used on locked-down systems like Android or cloud/SaaS.
Various developers and companies complained that that form of FLOSS has been coopted into unpaid labor for FAANGs.
But has the GPL accomplished any of this in practice? The Linux kernel rejected GPLv3 with it's tivoization clause, and for some embedded device it seems quite easy to avoid GPLv3 if you wanted. GPLv3, as it's adopted today, is just not a threat to evil companies that want to tivoize their products.
> You are probably thinking about weak/non-protective licenses. They are commonly used on locked-down systems like Android or cloud/SaaS.
> Various developers and companies complained that that form of FLOSS has been coopted into unpaid labor for FAANGs.
Again, what has been accomplished here? AGPL has been soundly rejected, and plain GPL doesn't really protect against the FAANGs.
It's not like if left-pad had been AGPLv3, all the FAANGs would have bought some expensive proprietary license to use that awesome library. In reality, nothing would have been gained by pushing away freeloading FAANGs.
I'm not saying you're wrong to worry about FAANGs. I think massive economic inequality, and the extent to which economic wealth can be turned into political power is poisonous to democracy. I'm just increasingly skeptical that copyleft licensing is a meaningful tool to combat this. And no, I don't have answers either..
Go figure.
At the end of the day, I prefer free software, because it's not user hostile.
It's a tradeoff. And I think for a while there in the midst of the history of free software an idea took hold that we could have our cake and eat it too -- that you could provide free software (as in Free software, capital "F") AND earn revenue as a for profit business to profitably sustain a company and extend its ability to contribute free (Free) code.
I wonder if recent history has shown that this is unrealistic. Maybe we should go back to seeing free software as almost accidental, as a wonderful anomaly -- when incentives are aligned correctly, you can subsidize its development, through government funding, or university research, or nonprofits, or hail mary last-ditch business efforts, or self interested loss leading spending by corporations (a bank contributing patches to a Java library, for example).
(I don't think this contradicts the goals of GNU, by the way. Because successful Free software tends to just keep going and live, and even seeming moribund code can be resurrected at any time because the code is out there, I think we could end up using free software for a higher and higher percentage of our computing lives as time goes on, even if its funding is ad hoc and unreliable on balance.)
What? Google was the first search engine that actually published papers on how their search engine works, and they've continued to do so through the years. Nearly everything that Google does can be linked to academic and industry publications written by Google employees that describe exactly how their systems work. The only things they keep private are the techniques they use to prevent people from gaming their ranking algorithms.
> You don't even know what data they have on you, and how this is used!
Again, what? https://takeout.google.com has exactly that information, and again, they were the first company that ever did this, and the vast majority still don't.
Google has been incredibly transparent, and they're key reason why the open source community is where it is today. Did people forget what the world was like before Google? Do you remember Embrace Extend Extinguish? Open Source Software was under a full on assault by the software industry. The idea that a software engineer could work on open source software on their free time, let alone get paid for it, was a completely foreign notion.
Google hasn't relied on PageRank for over a decade, and they will not tell anybody how their ranking algorithms actually work for trade and legal reasons.
Any takeout link is not going to allow you to download dark profiles, etc.
So goes the rest of the post.
- JordiGH's "Exercising software freedom on Firefox" <http://jordi.inversethought.com/blog/exercising-software-fre...>. Jordi spends a lot of time dealing with the infuriating reality of what it takes to build Firefox. The punchline (not stated in the post) is that Firefox uses an Emacs-like architecture, so basically none of these frustrations or the time wasted on them were actually necessary; the code Jordi wanted to twiddle require no/little actual building. The Firefox team (particularily given how well-funded they are) could enable a contribution path where making an improvement to Firefox is about as easy as opening up an elisp file and making the requisite tweaks, but they don't. Related, and I've mentioned this before—the Zotero app is built on XULRunner/Gecko, but XULRunner was killed by the big brained folks who had the power to do so in an attempt to free up resources for their totally successful designs for the future. Rather than throwing Zotero contributors under the bus and into a potential quagmire of dealing with C++ and Rust compiler output that they don't care about on failed builds, and costing them hours for successful builds (if a successful build is even possible for that contributor's hardware), the Zotero build scripts instead download Firefox and then repack it, et voilà—when you open it you're running Zotero. (Side note: former Mozillian here, and there's no real excuse for why the Firefox contribution process itself hasn't worked like this for the last 10 years except for Mozilla's infamously poor competence at almost all things re project management.)
- In "Open Source is not enough" <http://web.archive.org/web/20150828195814/http://adamspitz.c...>, Spitz succinctly lays out the problem. Open source may remove legal barriers and some of the practical ones, but not enough of the practical ones to actually enable the sort of mastery and control that is often talked about when people describe FOSS. (Spitz uses the term "open source" throughout, which is unfortunate, because Spitz's overall motivation has a lot in common with the GNU philosophy and serves as an incidental critique of the GNU project's actions which perpetuate a world with less of the "software freedom" that it advocates. A casual reader might mike the mistake of thinking that Spitz's essay either treads the same ground as Stallman's Why "Open Source" misses the point of Free Software, or that it is endemic of the problem that Stallman's essay exhorts people to acknowledge [and where the prescription is prioritizing GNU-style "software freedom" over "open source" ideals], although it's neither.)
- The ind.ie folks (now the Small Technology Foundation) attempted(?) to build some mindshare around their Ethical Design Manifesto <https://2017.ind.ie/ethical-design/>. I think this, too, makes an unfortunate choice of words, but despite the name, I see it as aligned with what Spitz and others are trying to shed light on. Funnily enough, I recently contacted one of the Small Tech folks about a simple error on one of their pages, where the fix for it was straightforward—fixing a typo, or fixing a broken link or removing it or something like that. The response was essentially an acknowledgement of the problem and an admission that it wouldn't be fixed immediately, as a nod to how mildly cumbersome it would be go in and make the change. Deep lessons about malleability and habitability (see below) lie here, waiting to be absorbed.
- In "Free software is not enough" <https://jfred.dreamwidth.org/479.html>, jfred relies unknowingly on an eerily similar hook as the one from Spitz's take. The problem described is the same, but jfred goes on in more detail, with references to Smalltalk and OLPC, and to its further benefit does so by referring throughout to "free software", thus avoiding the pitfall in Spitz's piece. jfred also introduces something that will probably prove useful in the long run if we are to actually address this problem: the notion of what he calls practical user freedom, nudging us to discuss it in the same terms. (I know at least one other person, Mike Gerwitz, who's claimed to at least have used or thought about using the same term privately.) Also of interest is that jfred uses modifying one's web browser as an example as well.
- Independently, on the mailing lists for IceCat—the official project to maintain a FSF-approved fork of Firefox—there are occasional mentions of folks' inability to get the thing to build. I suspect there are many more private failures than public mentions, maybe even 10 to 1. In fact, in the past, I've explicitly referenced the problem here on HN and elsewhere of what is probably tens of thousands of potential contributors who quietly drop out after a private bout of trying to do basic things that any given project's own maintainers and existing contributors take for granted, like just achieving a successful build from source. I'm fond of referencing Soledad Penadés's post "How to keep contributors when they are not even contributors yet" <https://soledadpenades.com/posts/2015/how-to-keep-contributo...>, although granted I do so much for the title than the content, really. In that vein, more recently I've taken to pointing people towards Maxime Chevalier-Boisvert's "They Might Never Tell You It's Broken" <https://pointersgonewild.com/2019/11/02/they-might-never-tel...>. Considering GNU's advocacy and messaging about what the IceCat project means for software freedom, in contrast to the reality of the situation, this is a problem. When I take this in at the same time as contemplating what has to be mountains of unactualized talent and aborted attempts to expand software freedom in light of so many people quietly scuttling their work after a failure reach the most basic milestone of being able to reproduce the conditions for a successful build and then to achieve one, I can't help but think about Feynman's comments wrt the oil drop experiment and his exhortations about what not to "fool ourselves" about. It doesn't quite fit, but the connection is there in my mind.
- More recently, I've re-visited Kartik Agaram's essay on "habitability" <http://akkartik.name/post/habitability>. Most people have failed to achieve systems that exhibit habitability. Not just ordinary non-programmers of the sort that would first come to mind when you read an essay like "An app can be a home-cooked meal" <https://www.robinsloan.com/notes/home-cooked-app/>, but as shown in the Small Tech and IceCat examples, the principled FOSS types fail to achieve it for themselves, too. So how can they hope to achieve it in systems that other computer operators are supposed to be able to inhabit?
- The Malleable Systems Collective <https://malleable.systems/> was introduced this past spring, but seems to have fizzled since then, possibly due to COVID-related dampening effects. I think the term is a useful one, although I'm still seeking something that fits in between "habitability" and "malleable" but manages to be something like 5–10x more useful because of its "obvious" meaning. I suspect that in the meantime I will get a lot of mileage by relying for now on terms like "practical software freedom" and others' being adequately initiated to be able to understand what that means.
- Stanislav at Loper OS lays lays down his Seven Laws of Sane Personal Computing <http://www.loper-os.org/?p=284>. Each one is interesting and worthy of consideration, but what I see as the most pressing matter is Law IV - Preserves meaning. What I see as a major problem is the continued use of 1980s-era infrastructure and practices. Compilers conceived originally as a tool to enable "autocoding" to a given machine's instruction set gave way to the now-familiar division between source code and the "binary" executables that are produced by mangling the source code. By now, doing away with traditional compilation entirely should be feasible by JITting everything—or caching the products but in such a way that the average programmer cares about them and deals with them no more than the typical programmer cares about and deals with the actual machine instructions that the compiler's code generator stuffs into the binary. That's one way to go, and probably what we should ultimately aim for. Another way to would be to adopt "non-destructive compilation" techniques to bring about a world where "package distribution is source distribution" at least in the interim <https://wiki.triplescripts.org/wiki/SDIPD>.
To summarize, part of a reason why the enemy that GNU seeks to take down manages to persist is due to a failure to acknowledge the circumstances that allow it to, and a failure to look back, see where and how the current strategy has failed, is continuing to fail, and indeed sometimes exacerbates the problem, and adjust accordingly.
I think it should be clear by this point, but none of the above is meant to say anything like, "The GNU philosophy is bad; choose BSD/MIT/ISC instead", a conflict which the GNU Project unfortunately directs too much attention to. You can just look at history and even the comments on this post to get a feel for how much human attention and energy has been wasted in that vein. So I add this only as a pre-emptive attempt to ward off low-effort and ill-considered potshots, because what I'm saying is very much the opposite—GNU doesn't go far enough.
IIRC the plan was for Zotero to rebase on Electron, though I haven't followed how this project has proceeded.
> (Side note: former Mozillian here, and there's no real excuse for why the Firefox contribution process itself hasn't worked like this for the last 10 years except for Mozilla's infamously poor competence at almost all things re project management.)
As a former Mozillian myself, I agree it's quite sad that so many paths that would have eased contribution and supported a universe of surrounding projects were sacrificed on the altar of Firefox. The management team at Mozilla doesn't seem to understand the huge impact the organisation could have had by supporting a whole ecosystem and way of building / thinking about software.
> The Malleable Systems Collective <https://malleable.systems/> was introduced this past spring, but seems to have fizzled since then, possibly due to COVID-related dampening effects.
(With my Malleable Systems Collective organiser hat on...) I think it's been a difficult year for most people, and it has been harder than I hoped to find time for this effort in 2020. Actually though, the website is a bit deceptive: while the blog has been pretty quiet, the Matrix room (https://matrix.to/#/#malleable-systems:matrix.org) has an active community regularly trading ideas in this space.
I'm hoping to have some more time and energy in 2021 for both experiments and writing that add to both the collective and the more general conversation that you are highlighting here.
This has some resemblance to the "Capability theory" by Sen and Nussbaum in political philosophy (or development economics, or however you want to classify it). As a very short example, various political freedoms someone may have are but so many empty words on paper if said person doesn't have any practical means of exercising those freedoms.
Messy as my piece above is, hopefully there's enough there and/or it's received at a deep enough level for a sufficient number of folks that it doesn't smolder out. There's a flame here that I'd like to see kept alive and hopefully renewed, ideally at a frequency matching how often these discussions periodically reappear, or at a minimum some fraction of that—at least until we've arrived in utopia.
Right now I'm watching Walter Bender talk about "Sugar Labs: Past, present, and future", demonstrating "Music Blocks" ("Meow!").
https://media.libreplanet.org/u/libreplanet/m/sugar-labs-pas...
At its peak, half of the contributions to the Sugar code base were from kids!
Walter's responsible for the OLPC having a dedicated "View Source" key on the keyboard.
http://wiki.laptop.org/go/View_source
>The View Source button fn-space and some alternative key combinations in particular activities allow one to look behind the activity, peeling away layers of abstraction in order to reveal the underlying codebase which makes it tick. This feature will integrate cleanly with the Develop activity, encouraging children to view, modify, and redistribute variations on the activities they use. Through collaboration and sharing, a garden of home grown activities will begin to develop on the laptops, created by the children themselves.
http://wiki.laptop.org/go/Keyboard
>the View Source key has a gear on it, is accessed as Fn-Space, and displays activity or system source;
Video: Prefab: What if We Could Modify Any Interface? Target aware pointing techniques, bubble cursor, sticky icons, adding advanced behaviors to existing interfaces, independent of the tools used to implement those interfaces, platform agnostic enhancements, same Prefab code works on Windows and Mac, and across remote desktops, widget state awareness, widget transition tracking, side views, parameter preview spectrums for multi-parameter space exploration, prefab implements parameter spectrum preview interfaces for both unmodified Gimp and Photoshop: http://www.youtube.com/watch?v=lju6IIteg9Q
Video: Content and Hierarchy in Prefab: What if anybody could modify any interface? Reverse engineering guis from their pixels, addresses hierarchy and content, identifying hierarchical tree structure, recognizing text, stencil based tutorials, adaptive gui visualization, ephemeral adaptation technique for arbitrary desktop interfaces, dynamic interface language translation, UI customization, re-rendering widgets, Skype favorite widgets tab: http://www.youtube.com/watch?v=w4S5ZtnaUKE
PDF: Prefab: What if Every GUI Were Open-Source? Morgan Dixon and James Fogarty. (2010). Proceedings of the SIGCHI Conference on Human Factors in Computing Systems. CHI '10. ACM, New York, NY, 851-854. https://web.archive.org/web/20141024012013/http://homes.cs.w...
>ABSTRACT: Current methods for implementing graphical user interfaces create fundamental challenges for HCI research and practice. Researchers are often unable to demonstrate or evaluate new techniques beyond small toy applications, and practitioners are often unable to adopt methods from the literature in new and existing applications. This position statement examines a vision in which anybody can modify any GUI of any application, similar to a scenario where every GUI of every application is open-source. We are currently working to enable this vision through our development of Prefab, using pixel-based interpretation of GUIs to enable modification of those GUIs without any cooperation from the underlying application. We see participation in the FLOSS HCI workshop as valuable in at least two regards. First, fully realizing this vision will likely require a community-based approach, so we are interested in Prefab as a platform for collaboration between HCI researchers and the FLOSS community. Second, enabling arbitrary modification of any GUI would seem to blur many current distinctions between open and closed applications, introducing new research questions and further magnifying the importance of the workshop’s focus.
I wrote more about it here:
jfred here from that link; thanks for putting together this summary. I'd seen some of these before (I mentioned the Malleable Systems Collective in the post) but I hadn't seen some others, and it's nice to see all of these in one place.
>Another way to would be to adopt "non-destructive compilation" techniques to bring about a world where "package distribution is source distribution" at least in the interim <https://wiki.triplescripts.org/wiki/SDIPD>.
GNU Guix does this to some extent. Guix packages are build definitions that refer directly to upstream source URLs rather than source tarballs or binary packages, and while there are typically binary packages available (as long as they've been built on CI, which they aren't always - resource constraints, etc) it's always possible to build any given package locally with `guix build <package name>`. The ergonomics around trying out modifications of these package definitions locally aren't as nice as I'd like, but it's been improving.
I'd be curious to hear what kind of modifications you do and how they can be made more comfortable. I suppose you are using object inheritance in a channel, file or manifest?
As for how, it depends on what I'm doing. If I'm modifying a single package, I might reach for inheritance first (in a file or manifest), although it depends on whether or not that package is at the end of a dependency chain. If it is, inheritance is fine; I'll inherit the upstream version first, change a few fields, and try building/installing it. If not, though, I might be trying to update a library but the program I really care about is an application further down the chain; then I'll typically work from a local Guix checkout so that I can update the library then install the application.
Regarding the ergonomics of each of these:
- If I'm doing something that involves working on a Guix checkout... well, that involves looking up where to find Guix's source code, `git clone`ing it, finding the Guix revision I'm currently on with `guix describe` so I can check out the same one for consistency's sake, `make`ing it, `guix environment guix`, using `pre-inst-env`, etc. I don't really have a problem doing this, but I've also been working with Git and GNU/Linux for years now. It's not very approachable to beginners. Don't get me wrong, it's easier to make changes to Guix than it is to most distros, but I still think it could be better.
- Inheritance can be pretty convenient, but of course when you finish working on something and want to go contribute a patch, you have to go get yourself a Guix checkout anyway and copy your changes over.
I think in my ideal world, there would be a command like `guix edit`, where `guix edit foo` would do something like... give you a local editable checkout of Guix, open an editor to the file at the line where the start of the package is, give the user a quick way to build their new package, etc. I haven't thought through exactly what the UX would be, but essentially the idea is to have the closest thing possible to an "edit source of <package>" button. Bonus points if it can walk the user through the upstream contribution process, and maybe automate the more trivial commit messages for things like adding a new package. I always have to look up that format as I don't contribute packages very often.
This is not to say that what's going on behind the scenes should be completely hidden (verbose flag that shows what commands you could have run?), but providing a simple on-ramp to contributions that doesn't require much pre-existing knowledge is huge for engaging beginners (and even non-beginners who just don't have much time on their hands).
Guix is very hackable as you mention, but with a very different design from e.g. Gentoo, where you can easily override anything in /etc/portage.
I like your 'guix edit' idea; the command already exists, but it opens a read-only copy of the Guix source code by default... It would be really nice to add a tutorial of sorts to it and make it interactive.
Note there is an Emacs 'yasnippet' that fills out part of the commit message: https://guix.gnu.org/manual/devel/en/guix.html#The-Perfect-S...
I agree that the onboarding story could be better. If emacs-guix could guide a user all the way from 'guix edit' to 'git send-email' that would be nothing short of incredible.
Thanks for your thoughts. :-)
And thanks for the tip about the snippets!
But my problem is that his ideas are too rooted in Kumabya reasoning.
For instance there is almost no literature on how people can adequately profit while still maintaining this philosophy.
It's a great idea, but they need to talk more about how to real people actually use it. Not just what it's about
Where can I inspect that path? Could u help with a link?
I used to be hard-core in the free software camp, and while I wouldn't say I have abandoned it, my stance has certainly softened. A couple of recent articles and presentations that have affected (or mirrored?) my own thinking:
http://dtrace.org/blogs/bmc/2018/12/14/open-source-confronts...
https://archive.org/details/copyleftconf2020-allison
A couple of quick takes
- The tivoization issue: The rejection of GPLv3 by the Linux kernel in practice means that the free software movement has failed here. I'm hoping activists pushing for Right to Repair and similar legislation will prove more successful in enabling people more control over their own devices.
- The cloud service provider loophole: The almost complete rejection of AGPL by, well, more or less everybody, means that the free software movement has also failed here. Plain GPL doesn't provide more protection against a service provider "leeching" your code than a permissive license. If copyleft has failed here, what are alternative approaches here then? Data portability and anti-trust legislation?
- Protection against leeching by evil corporations vs maximizing usage: If, like some of the core Linux kernel people have said, "there's no value in driving freeloaders away", is copyleft worth the trouble?
- The end user vs. developers argument: The FSF spends a lot on this, about protecting the rights of the end user. But if we look around at non-techie people, largely they just don't give a shit. Perhaps the copyleft movement needs to work on its messaging, or is this a completely lost cause.
- FOSS business models: To begin with, trite as it sounds, "write FOSS" is not a business model. The more interesting question is perhaps how build FOSS communities that can, in one way or another, sustain themselves economically.
- If you don't have a plan to make money, does leeching (see above) matter? And no, "I'll license my code under (A)GPL, if somebody wants another license call me and lets talk $$$" is for the vast majority of cases not a realistic business model either.
- Dual licensing: Not really applicable for trying to build a community. Why would an outsider contribute and assign copyright to a project under a "poison pill" license so that someone else can make a buck off that work?
- Open core: Evidently successful (see e.g. cossi list), but is this really FOSS, or is it proprietary software with an open source loss leader?
- Commodity community: Essentially sharing the maintenance burden of the non-differentiated part of whatever you're doing. The Linux kernel being a good example of this.
- Support or selling "LTS" licenses: E.g. redhat. Can work, but seldom achieves the kind of growth numbers that makes VC's salivate (if that matters to you).Users take advantage of free software mainly in the few domains where copyright and patent law don't get in the way of free software. Free software is largely irrelevant in the greater number of domains where copyright and patent law prevent the user from doing anything of value with it.
E.g., let's go back in time and use free software to build a world encyclopedia. Yay, we made a quintessential use case! And in record time!
E.g., let's go back in time and use Lilypond to publish beautiful, diffable text-based TABs, melodies, and lyrics for everyone's favorite songs in the world. Boo, I must have set the time machine too far back and got eaten by a T-rex. Sorry, users.
In this way a lot of the most useful Gnu software remains "shadow banned." It gets used for niche projects, and a dev can certainly conceive how, say, some domain would be improved if they just adopted free software so-and-so. But the uses that would attract and benefit massive numbers of users are off the table. And neither Gnu nor FSF has the power or competency to make the changes to copyright/patent law in order to enable those uses.