A pragmatic approach to software usage and development.
Free and open source software has affected every area of computing, from the client devices we carry in our pockets that are based on BSD (iOS) or Linux (Android) kernels, to the mostly GNU/Linux servers and supercomputers that power everything from Facebook to the New York Stock Exchange. Free software is inarguably the basis for almost everything we do with modern computers.
Even when proprietary software vendors like Microsoft develop new products, they’re known to “Embrace, Extend, and Extinguish”, that is to say, they embrace open standards and the functionality of Free or open software, add their own proprietary modifications (so that they’re the only provider and support vendor of those new features), and finally, they seek to become the default provider of the services and features they originally copied from Free and open projects. This results in proprietary vendors being the “industry standard”, as that’s often simply the default – most people don’t want the hassle of switching software, especially their operating system, but even the tools that run on those systems as well. Usually we just use what came with our machine.
While Microsoft famously coined the phrase “Embrace, Extend, Extinguish”, we also see almost every other major software vendor using the same philosophy. macOS and iOS are based on the open source BSD project, they use GNU system utilities, and yet, they tack on a graphical interface (the only part that 99% of users will see) that’s completely proprietary and closed. Adobe uses this philosophy when it comes to creative content and especially the web. Remember “Flash”? That was an Adobe product that used to be found on almost every website. Websites that were otherwise totally compliant with open web standards had to license proprietary Adobe tech. in order to play a video or a simple game. Of course HTML5 has replaced the need for Flash, but Flash would likely still be in widespread usage today were it not purposely depracated by Apple and Google on their mobile operating systems. You can save your Adobe files in open formats like SVG and EPS, but of course, those are not the default, and Adobe’s formats usually have not only all the features you’ll find in the open formats, but also proprietary additions that you’ll only get from a single vendor. Even Google, with it’s motto of “don’t be evil”, seemingly thinks “Embrace, Extend, Extinguish” is not “evil”, as they’re obviously quite keen on using that approach. With every Android release, more of that open source operating system’s features are pushed out of the OS, and into Google’s proprietary Gapps suite. From email (Gmail), application hosting and vetting (Google Play), and office work (Google Docs), all the way down to the OS (Google is working on Project Fuscia, a proprietary replacement for Android itself), Google is *VERY* much an “Embrace, Extend, Extinguish” type of player.
So here we are, we’ve been given the gift of “Free and Open Source Software”, and everyone uses it, even those who would rather not in the long run. What do we do?
The problem I see with staunch Freedom fighters is that they’ve created all these wonderful tools and entire ecosystems, and are aware that others are “Embracing, Extending, and Extinguishing” them, but when we ask what we’re supposed to do about this problem, we’re sometimes told that if a proprietary piece of software exists and has some functionality that we want or even need, we shouldn’t use that software, even if no alternative exists.
This doesn’t work. Quite literally. If I have a job to do that’s impossible without or made faster by the use of a proprietary piece of software, and I want to be a stickler for freedom, I cannot do that job or task. No “Free” tool for that job? I don’t work. This approach doesn’t work. And in fact, if we follow the history of Free software we’ll find that that approach wasn’t even the one used when GNU, Linux, or any of the other amazing Free software projects in the world, were created.
Adopt, Adapt, Abandon
This is what I’ve personally done with many of the tools I’ve used. It’s what RMS did when he created the GNU utilites to replace the proprietary Unix tools he had been using. It’s what Linus did when he created the Linux kernel as a replacement for Minix. Let’s examine how this has worked, and how we can *grow* open source, *reduce* our dependence on proprietary tools, and *fight* the cancer of “Embrace, Extend, Extinguish”.
Firstly, we throw out the notion that we can never use proprietary tools. We should use them. Those proprietary vendors are very much using open software when they embrace them, so it would be foolish of us to let the *enemy* steal and improve our weapons while refusing to use theirs at all.
Personally, as a content creator, there have been many times in my life and career when the open source tools simply did not do what I needed them to. I used to run Windows full time, then only when I needed a particular tool, and finally I erased it completely from my software collection when GNU/Linux (specifically Ubuntu) was able to match the ease of installation, software compatibility (even if it required running WINE), and hardware support of Microsoft’s OS. During that transition period, I paid for Windows licenses and used their OS, but all the while I was also using and testing the alternative (GNU/Linux), and contributing bug reports, end user installers (I’ve been the sole maintainer of DreamStudio, a content creator’s distro for about a decade now), testing of the hardware I use (sometimes modifying drivers or configs), and basically helping in any way I could to *reproduce* the features that didn’t exist in the Free offerings, and which kept me pragmatically tied to proprietary software. When the Free software achieved feature parity, I stopped buying Windows, and when I hadn’t used it for some time, I deleted it from my boot drive.
I did the same thing with multitrack audio software and DSP plugins. Buy the proprietary version (adopt), find the open source project that had *some* of the features I liked, help that project achieve feature parity with the proprietary solution (adapt), and finally migrate to the open solution once parity was achieved (abandon).
Isn’t this the same place all of our open source tools have come from? We didn’t just wake up one day and create GNU or Linux, we *used* UNIX (adopt), created tools to replicate the functionality (adapt), and finally when that toolset was complete, we switched to the new, Free version (abandon).
It’s okay to use software that works, I would encourage it, but we must always be looking for the exits before they lock the doors.