बस boycott all software
until software is free again
why boycott software?[lit]
*because free software failed*.
because when forces are oppressive, the choices are to resist or let them oppress. if you can come up with a smart, constructive way to resist, thats good-- free software was a smart, constructive way to resist. free software isnt necessarily the wrong way to fix this-- but free software reached "peak freedom" years ago. the movement is dying. if it comes back, that seems ideal.
how would you boycott all software?[lit]
remove it from your computer. the tongue-in-cheek instructions for becoming a "saint in the church of emacs" is to remove all non-free software from the computers under your control. no software is truly free anymore, so a saint would remove it all.
but thats stupid...[lit]
nobody thinks that anybody is really going to boycott *all* software. thats simply a baseline for the discussion of whats really free.
so youre not serious, then?[lit]
oh no, this is completely serious. the idea that free software has failed? serious. the idea that boycotting all software is the solution? also serious. the idea that no software is truly free anymore? serious.
starting with the perfectly serious idea of removing all software makes as much sense as the goal of free software, which is to make all software free. this isnt intended as a parody of that idea-- all software should be free. software which isnt free creates users which arent free. being against user subjugation isnt a joke. the costs of society being less free because of software arent a joke either.
but you are kidding just a little bit, right?[lit]
many old hackers are familiar with the phrase "haha, only serious". everyone trying to make the world a better place is kidding just a little bit. but "playful cleverness" is one of the things that keeps the human spirit alive.
there will be people who think this idea is spiteful and petty. not only is the point its making a serious one (even if theres a minuscule amount of playfulness in the way its made) and the solution proposed is at least 99% serious.
lets say i agree with your assessment of the problem. im not going to remove all the software from my computer, because then it wont work.[lit]
per the concepts pioneered by alan turing, most computers (the ones you would typically read this on) can do basically anything digital. to simplify, what they do is *run software*. if you remove all the software from your computer, **it will still run software**. it just doesnt have any to run.
but since there could be a few (firmware-related) ways thats not true, and since it wouldnt likely convince anybody in the first place, *the next best thing* would be to remove as much software as possible.
suckless is just an example. theyre one of the better known examples, so credit where credit is due. but suckless doesnt (yet) address the full scope of the problem thats being addressed here. suckless is one route to software minimalism.
all kidding aside, when thoreau recommended minimalism, there were several advantages-- it was living more in line with nature, a value that has persisted (at least in sentiment) throughout the history of human culture. it produced less debt, and with that less slavery and more freedom.
the arguments for minimalism are many and worthy of consideration, whether we are talking about software or many other aspects of the human condition. for the most part, the proposal of minimalism made here is for some fairly specific reasons regarding user freedom.
sustainability and freedom have a complex relationship. as rms has pointed out, when you talk about "freedom" its important to go into specifics. some people will feel sustainability actually restricts their freedom. the argument made here is that freedom which is sustainable is generally a more worthy pursuit than freedom that exists for the duration of license (to be altered or revoked at the whims of the license holder).
some people will use that last line as an argument against the gpl, but personally i find that argument cynical for the most part. they are entitled to their point of view.
software under a free license is free.[lit]
thats the idea, but its an oversimplification. while i would recommend keeping this as simple as possible, oversimplification of this sort of thing makes free software extremely vulnerable.
i recommend the free software definition as a baseline. this defines what freedom is, what free software licenses are supposed to offer. the simplest way to express the free software definition is to say that it allows you to freely "use", "study", "change" and "share" the software.
the freedom to "use" the software for any purpose was arguably implied by the other freedoms. however, drm and tivoisation made it wise to be explicit about the freedom to use the software for any purpose. the freedom to NOT use the software is also implied by the existing freedoms, but the success of free software can arguably be attributed to the fact that free software was always reasonably modular-- you didnt have to run what you didnt want to.
over the past few years, the de facto freedom to not use the software has significantly diminished. the effect of this is to make it possible for bad actors to hold software hostage. dont worry that this isnt proven yet; its offered here to help you understand the problem. the proof will come when it comes. some people already agree that this is a problem, others are scpetical. it isnt possible to prove everything to everyone all at the same time.
saying that software is free because the license is free, because the license is compatible with the free software definition, is a bit like saying that someone is free because they live in a free country.
even if you agree on the definition of freedom, and agree that the country a person lives in bestows that freedom, how free would you say that person is in a hostage situation? if youre taken hostage in a free country, saying that youre free because of the country youre in sort of misses the point. youre a hostage-- thats less than free.
we have plenty of evidence about bad actors. among the worst are giafam: six tech giants that use a mix of semi-free software and proprietary software to hold the user and their data hostage. this includes ibm and microsoft, who make effort to bypass software freedom through various means, including using low-quality patents to turn free software other people wrote into software they seek rent for.
this is a system of exploitation; where many people contribute to the software ecosystem without payment, and then corporations are the only people who get to profit financially. this is a digital form of indentured servitude. while theres no problem with volunteer work, exploiting volunteers on this level goes beyond the merely hypocritical and the simply corrupt. these companies dont care about freedom, they exploit it.
some people claim that free software cant be taken hostage, because of the free license. this is a circular argument, with notable refutations. software tries to perform a task or tasks via written instructions, and licenses also try to perform a task or tasks via written instructions. despite this effort, software frequently fails to do exactly what its authors wanted.
in the most harmless sense, this is referred to as a "bug" in the software. in the context of security, a bug that can be exploited to compromise security is a "vulnerability". the implementation of that exploitation is called an "exploit", and software that uses such exploits for purposes not desired by the user of the computer or software being attacked is called "malware".
my argument about software licenses is that like good software, they perform good tasks. they typically do a good job of these tasks, but saying that software is (undebatably) free because the license is free is not always correct. software under a free license is *theoretically* free. and thats good, thats the very first step towards software freedom and its arguably a necessary step. you should put software under a free license (preferably a gpl-compatible license, for most purposes).
where this theory fails is that a free license, like software, can have vulnerabilities and exploits. version 2 of the gpl had at least one vulnerability that the gpl authors did not want it to have, and that was not intended. tivoisation was an exploit of that vulnerability. gpl3 "patched" the known and exploited vulnerablity in gpl2.
software patched for known vulnerabilities is typically considered better than unpatched software, but patches come with costs and do not guarantee that there will be no more vulnerabilities or exploits in the future. i do consider the gpl3 a step forward, but one thing the gp3 cannot do is prevent lobbyists from working to get people to reject the patched gpl. it isnt reasonable to expect a license to do that; working to get people to accept patches is a job for people. licenses cant do everything. but thats kind of the point.
tivoisation was not the last exploit against free software licenses. many other attacks on free software have moved the entire movement (and its flagships) into "check".
if the free software movement was really fighting this, we could just keep fighting and there would be less software to boycott. unfortunately, the failure of the free software movement strikes at the very roots of free software and the gnu project. if we boycott the fsf (which i recommend, because it has grown corrupt) there is still the gnu project to protect.
unfortunately, as i have explained recently (and intend to explain again here)-- even the gnu project is compromised and being held hostage.
in order to save free software, we must also boycott it.
if we boycott free software, what do you recommend? non-free software?[lit]
no, no, no-- non-free software is still worse. but when your choices are non-free and barely free, the only software you should be accepting is actually-free.
we had that. and perfection aside, we had a free software movement that was headed *towards* freedom. the fact that it is now headed *away* from freedom, and that this is a direction sustained over several years, which continues to get worse (not better) is the reason that all software should be boycotted-- if not literally all software, then at least as much of it as possible.
no software is really headed towards freedom right now. there *are* some developers who still care, nobody said otherwise. and i dont believe that rms is compromised-- he still cares. but i dont agree with him that you should support the fsf. i dont agree with him that things can improve if you do so.
for the level of corruption that myself and others have talked about over the past 6-8 months (since rms was ousted as president) it is better to support nothing at all. dont sign your name to the coup, dont throw money at corruption, dont help the people working to destroy your freedom.
unfortunately, those who do care have yet to stop holding out for the hope that the corrupt and bad actors will for whatever reason relent. we are far past the point where "assuming good faith" is reasonable, or helpful.
arguably, the three greatest threats to software today, are censorship, github and uppity developers.
in this instance, "uppity developers" doesnt refer to people skills. theres a myth that every developer needs to work with other people; quite a lot of software started out with one person writing it, and thats not necessarily their problem or their responsibility-- to do anything after they put that software out into the world.
if the software is free then someone else can pick it up and create a community around it, if it even needs one. it's a nice feature when a developer goes beyond the task of writing software, but it isnt the requirement that open source has always made it out to be.
but that goes both ways, and it isnt the responsibility of a user to do what the developer wants either. cooperation, by definition is mutual. if it isnt, it's simply obedience-- and people who want freedom should be practicing Software Disobedience-- because Freedom 0 doesn't change just because an uppity developer doesnt understand it.
censorship is a bigger problem than rudeness. linus torvalds has changed a fair bit on the surface, most likely due to pressure from his owners, but none of the worst things about him have changed. torvalds isnt an example of the sort of "uppity developers" talked about here, since the obedience he expects is rhetorical and nothing to do with the software. sure, he is uppity about criticism of microsoft-- thats a separate complaint.
uppity developers act like Freedom 0 doesn't exist-- the freedom to use the software for any purpose. they criticise people for trying to make their software optional, and they frequently boast (or dishonestly insist-- then deny ever insisting) that users will have "no choice" (or very little) about running their software. it's one thing when people are claiming success and showing that other people use their software in a production setting or any other setting, but when that software is something people are being told to "get with with program" (literally? obey the software and obey the developer?) they're missing out one of the great things about software freedom: [url]https://www.fsfla.org/ikiwiki/blogs/lxo/pub/new-dawn.en.html[url]-- at least when software freedom is working.
developers and fanboys have said youll have "no choice" but to run gnome, many years before they lied (then denied) that you would need systemd to run gnome for example. whether it's true or some kind of sick joke, that kind of attitude-- of mocking and laughing at users about developer lock-in is much farther from a healthy attitude than some of torvalds' most passionate rants about contributions to the kernel.
heres another reason to use torvalds as an example-- theres noproblem with a lead developer trying to stop people that contribute code from breaking the project. if that wasnt a good thing, would projects really even need a lead developer? rather this attitude that these expectations extend to the user-- user freedom is as important as any, because all software developers are also software users. as long as it's possible to sabotage a project, it would be silly indeed to take issue with a lead developer protecting a project from sabotage or breakage.
many projects are making their work harder to fork and adapt, and thats far from beneficial. there is no perfect software, so there is no perfectly-forkable software; but while there can be no mandate to perfect anything, it's a real problem that so much software is going backwards in this regard-- that lock-in is increasing, and many people know it. it's not a new problem-- the scale however, is something you can put squarely within the past 5 years.
this is also why we may need a fifth freedom-- the freedom to not run the software. we should build that into as much so-called "Free as in Freedom" software as possible, because the freedom to NOT run the software was always implicit and present by chance. now that it's being deliberately eroded, that lock-in is being contributed as an ever-increasing problem; we can't rely on implicit and incidental modularity like we generally had until now. modularity has to become a deliberate feature-- within reason, of course. and not only for developers, but for users-- because they enjoyed it too. dont like something? just remove or replace it. that used to be so much easier (and less superficially true than it is today.)
but until these uppity developers become more fair and modest, it is also important to promote the kind of software that doesn't showcase that sort of arrogance. and github is still one of the largest threats to software freedom today; so while we promote the idea of an operating system that microsoft doesn't control [url]http://techrights.org/wiki/index.php/Github-free[url] (seriously, we have to do that again?) it's important to practice software disobedience with github-based projects as well. it's probably impossible (or at least very unlikely) to go all the way with this. it's a gradually worsening problem with a solution that can probably also only work gradually.
so software obedience is about:
1. ignoring that Freedom 0 exists
2. letting developers control you by having too much control of your software
3. abandoning and removing modularity to create further lock-in
4. letting monopolies control free software development
and software Disobedience is about:
1. strengthening Freedom 0, along with the other software freedoms
2. resisting the messaging and machinations of uppity developers who want to control your computing
3. abandoning, replacing or when possible, forking software that adds to lock-in (as the libreoffice developers did when openOffice became "less free")
4. abandoning, replacing or when possible, forking software that is controlled by monopoly forces such as github
and "ps aux" says fluxbox has run for less than one hour; until somebody commits to a serious fork of this window manager however, it's time to try to find alternatives. For many years, I have looked for ways to promote and bolster software freedom. software disobedience matters more at least than a window manager that props up the microsoft github monopoly. even if we cant have a microsoft-free, github-free operating system that doesnt prop up their monopolistic abuse, it's still better to move in that direction.
it's also probably important to have smaller components working first. when it's possible to replace a larger solution-- like gnome 3 with mate, if you never liked the attitude of gnome 3 developers (or found them even worse than when you used gnome 2). the thing is that smaller projects are easier to fork, easier to maintain, and easier for an everyday hacker[lit]/[lit]coder (jane or joe coder) to fix if they need to. security patches are an important part of the ecosystem as well, though it's still harder to patch something enormous and keep bugs out in the first place.
while larger software projects arent all bad, we should probably consider smaller applications like fluxbox and wget a higher priority than larger applications. if the utilities we rely on to work when nothing else does are not taken care of, then we lose the foundation for our operating system-- and the things we can fix and re-liberate most easily.
on that note, someone is trying to convince fluxbox developers to move development to github. simply based on commits, it's very possible we will lose fluxbox to github in the next year or two.
fluxbox is an obvious transition from icewm (as jwm is also github-based) but dwm is worth another try. suckless.org has a good philosophy, steve litt loves and promotes dwm. it's nice to have something a little more conventional as an option-- gnome 2 was worth promoting for people that might want a little more hand-holding compared to xfce.
as compromises between friendliness and resource usage go, lxde was probably the best, but it's now developed on github. xfce and gnome 2 were "steps up" in terms of features but steps down in terms of being lightweight. for myself and anybody who wanted basic, familiar features with incredibly light resource use and best speed on old computers, icewm was the best-- even on machines with several cores. why waste cpu, ram and gpu on moving rectangles around?
but since windows xp came out, microsoft hasnt gotten any better as a company; they are far worse than ever. walking away from monopolies is the essence of freedom, and we should explore the alternatives to microsoft-controlled projects, as many of us did when we switched to gnu in the first place.
we have grown a little too obedient, a little too complacent with being told what to do, and while the philosophy as well as the significance of corporate corruption is important-- it's also important to act. sometimes we need to decide that now is the time to take another step.
and no, fluxbox wont help much if github takes it over. but it gets another chance right now, because it seems farther away from github than some ideal window manager. that's a status worth watching closely-- and the community will know soon enough if it's too late for fluxbox. naturally, a window manager is just one example of the sort of software we need to be able to get away from the monopolistic control of microsoft, and the rest of giafam.