everything wrong with free software

 "obedience breeds foolishness"

### the-wonders-of-modularity previous: => some-computer-history.html some-computer-history *originally posted:* apr 2021 as mentioned in the previous section, the first computer i really got into using relied on three files to start up: ``` msdos.sys io.sys command.com ``` the first two handled the actual system, and command.com was the command interpreter. you could do all kinds of things with this system, for example you could create a file called autoexec.bat and have it run commands automatically when you start the computer. autoexec.bat had the power to display a text file, run a text-based menu, or even start a graphical shell (windows was only one of many options). files that ended in .bat were called "batch" files because they ran "batches" of commands. these days, most people call those "scripts". the simplest commands are single words that do one thing. for example: ``` cls ``` cleans all the text off the screen, just like erasing a chalkboard or whiteboard. on most of the systems i use now, "clear" performs the same function. "cls" was a well-known command in both dos and basic, which is why its the name of the clear screen command in fig (which takes many of its command names from basic). most of the time, a single command like "clear" points to a single file thats stored somewhere on the computer. we can run "which clear" to find out where the file is: ``` which clear /usr/bin/clear ``` on this machine, the clear command is stored in the bin/ folder, which is in the /usr/ folder. the leftmost / tells you that /usr/ is in the top folder of the system; there are no folders higher than "/". note that which is a standard utility, but the only which i know is from the gnu project, and it has moved from a place that the gnu project controls (gnu savannah) to github, which is controlled by microsoft. microsoft is one of the oldest natural enemies of gnu, so to protest this ive created my own (very limited) public domain which replacement-- it looks like this: ``` #!/bin/sh for each in $(echo $PATH | tr ":" "\n") ; do ls $each/$1 2> /dev/null && break ; done ``` this may look complex, because it does a lot in a very small amount of code. you can use a different language (an easier to learn language) or write this in a different way, and still have it do the same thing. but what it does is look through the folders named in $PATH for the command we typed in, which is "clear", but to the script it is represented as $1. whatever command name you type, the script will get it from $1. if it doesnt find the file of that name, it looks in the next folder, and if it finds it then it stops. this all happens pretty much instantaneously and when we type in "which clear" it says "/usr/bin/clear" on the next line. now maybe you dont think a "which" command is needed at all... i would warn you that another program might use it or need it, but maybe you dont even care what other program need it-- you want to delete it. first you need to find it. you can search the entire computer for a file named "which", but while we have the which command we can use it to find itself: ``` which which /usr/local/bin/which ``` this one is in the /usr/local/bin folder. so as root, we delete it with the rm command: ``` rm /usr/local/bin/which ``` and now any programs that truly need which, simply wont work. maybe we will delete those too? so weve demonstrated a simple command called clear, weve located it with which, weve used which to locate itself, and deleted it with the "rm" (remove) command. we cant run the which command now, but we can put it back! if you have another copy of which somewhere, you can copy it to /usr/local/bin with the "cp" (copy) command. or if youre feeling adventurous you can actually type it in manually: ``` cat > /usr/local/bin/which #!/bin/sh for each in $(echo $PATH | tr ":" "\n") ; do ls $each/$1 2> /dev/null && break ; done ``` the first command says to run "cat", which is an interesting command that just takes whatever you type and echoes each line to the screen. the ">" tells it to write to a file instead of the screen. then we type in the contents of the file formerly known as /usr/local/bin/which, and cat keeps waiting for the next line. we get it to stop doing that by holding CTRL and pressing D. this is also known as "CTRL-D" or sometimes ^d but it tells cat to exit. if you do it twice it will also quit the command shell (dont do that yet). so now we have run a program, located it with another program, deleted that locater program with a third program, plus weve even used a fourth program to recreate the locater program. and all this without a single click from the mouse (you dont even need one plugged in for this). but no matter how awful this looks to you: ``` #!/bin/sh for each in $(echo $PATH | tr ":" "\n") ; do ls $each/$1 2> /dev/null && break ; done ``` please note, you dont need to understand that code to USE it. the part you need to KNOW (if you want to use it) is: "which commandname". thats whats great about commands. they can take complex instructions (far more complex than the example here, too) and reduce those to a single, easy to type command name. sometimes the command doesnt go to a small utility at all, but a large suite of programs like windows or (better yet) x. the startx command runs a free (as in freedom) alternative to windows, but it consists of many components that let you run some or all of them or (if you dont need a graphical shell) none at all. but what if you make a better alternative to x? some people have tried, but if this is done properly you dont really have to choose; the way these things traditionally work is that you can have both installed on your computer, and simply run the one you prefer. in recent years, people have paid less attention to this convention, in an effort to drag people along into their (corporate) way of doing things. this goes against a lot of different principles at once, but the (corporate) sponsors (like red hat) certainly like it. in the old days, if you didnt like windows, you could simply delete it. then, a lot of hardware support moved from the system that supported windows into windows itself. before, if you wanted your hardware supported you just plugged it in and installed some support software. but eventually you needed to be running windows (at one time, an optional shell) to have the hardware supported. in this way, windows became less optional and dragged the user along into running it whether they wanted it or not. years ago, a relatively easy way to get away from this trend was to get away from microsoft (and ibm) and run something like gnu/linux. but then microsoft purchased github, ibm purchased red hat (who already controlled a lot of these software alternatives) and now unless you want to be a victim of their monopoly all over again, modularity will require another mini-revolution like the one that gave us the gnu project. although building the system up (yourself) gives you far more control than taking pieces of it down, we saw in this very section that sometimes removing part of the system (and even putting it back) isnt really that big of a deal. thats the way its supposed to be. in the early days of gnu, modularity was a de facto pillar of user freedom, which made it easier to port (and easier for the user to control) parts of the system to other machines or remove parts that werent wanted or needed. with people attacking that de facto freedom, it may be better to make it explicit. i thought that would be tricky, because absolute modularity isnt necessarily practical or desirable. but there are debatably grey (non-absolute) areas in the free software definition such as freedom 0 and the concept of obfuscated source code (as being undesirable), so i think peter boughton managed it nicely: > "The freedom to NOT run the software, to be free to avoid vendor lock-in through appropriate modularization/encapsulation and minimized dependencies; meaning any Free software can be replaced with a user's preferred alternatives (freedom 4)" while not officially part of the free software definition, this is the freedom i think that has been eroded and i think to some extent, some of the established 4 freedoms really depend on it. the problem is that this "fifth freedom" worked behind the scenes and wasnt appreciated by quite enough people until it had been attacked and undefended. whether it becomes part of the free software definition or not, i think letting this freedom be eroded further will ultimately erode freedoms 0 through 3, at least partially and to a tragic (and avoidable) degree. celebrating modularity and exercising it by removing software you dont want or need is one of the best things you can do for freedom right now. in august of 2020, i became so tired of reduced modularity after years of fighting "simulated lock-in" in otherwise free software, that i removed my entire operating system-- and replaced it with one that was more modular. in 2007 i migrated all my machines from dos and windows (and gnu/linux) to gnu/linux. i did it for freedom. in 2020 i did this again, moving to openbsd. i know that openbsd has some non-free parts, but it is actually quite strict about those (in the base installation) except for firmware. its not like i invented the idea of making a fully-free bsd. people are already working on it. but i think a gnu/linux system that truly respects your freedom-- which was a reality in the past, is impossible today. a fully-free bsd system is not. nobody who promotes trisquel or (most) other fsf-approved distros is going to consider openbsd to be "more free" than say, trisquel-- but i used trisquel myself, and i made i version of trisquel 8 that is MORE FREE than trisquel itself, and they didnt care about that at all. id rather aim for freedom that has a future than freedom that has stopped caring. thats why i use openbsd, and look forward to a fully-free version of bsd. modularity is only one aspect of user freedom. but its probably the one that needs the most attention right now-- not to the exclusion of other freedoms, of course; but certainly to the exclusion of corporate sellouts and lovers of ibm hegemony which truly isnt freedom at all. and no, i dont recommend dos anymore-- even dosbox is controlled by microsoft. but we can still take the page from its book which says, have a very lightweight and very (simple) modular system, then build other modules on top of that. tying it all together with what steve litt has called "gratuitous interdependency" is a dirty trick designed to put monopolies back in control of your computing. anybody who stands for that has lost much of their ground to preach to you about "your" software freedom. the freedom to be controlled by ibm and microsoft, to have them replace things that communities were able to build and maintain for years with bloated garbage more exclusively suited to big contracts and billion-dollar corporations, is not freedom at all-- but it IS a hallmark of "open source". => https://wrongwithfreesw.neocities.org