My Next Project Won't be FLOSS

OK, it might… But my next big project won’t be FLOSS.

I’ll get to this but first…

So let me start at the very beginning.

History of FLOSS

Formally Free Software started in 1983 but in spirit it goes way–way back into depth of time. The idea of sharing was around since the dawn of humanity. Even before that. First stone tools date some 3.3 million years ago. That’s quite some time before our species even came about. There was no copyright to protect, no patents to file, no profits to secure. But some australopitecus banged two stones together and in an instant invented a sharp stone, stone tools, and invention itself. And this extraordinary individual shared the technology with others. Well, I believe they shared because it’s easy to steal a sharp stone but hard to steal the knowledge how to make a sharp stone especially taking into account extremely limited or completely nonexistent language at the time. So this inventor had to show others how to make sharp stones. And since then sharing of technology stayed with us.

Of course, it was in tension with other motives. The powerful tried to keep the technology that made them powerful all to themselves. Like Egyptian priests invented automatic doors to make it look like they have magic. Quite an advanced machine but was installed only in temples to impress and reinforce priests’ power. The wealthy that tried to keep the technology that made them wealthy all to themselves. Damascus steel comes to mind. But the desire to share was with us all along anyway.

Let’s jump to a relatively recent time—1950s. The first computer was invented and with it the first actually useful software. For a while computers were so big and expensive that they had to be shared. I mean, a bunch of people could use the computer together. And they wrote software for those computers and it was a no brainer that they shared software. What else would you do with it if there’s only one computer that can run your software?

A little down the road computers got a little less expensive. To the point that it made sense to make a few of the same model. IBM in particular made a business out of it. But computers were still so expensive and so few that no one though of commercial third-party software. These computers mostly ran bespoke software specific to the organisation that owned the computer. And people who use those computers and wrote some generally useful software shared it freely. IBM recognised this as a good thing and even encouraged sharing. They themselves distributed source code for their mainframes’ OS. Many of these computers were installed at universities and you know these nerd: they don’t care about profits, all they want is discovery, collaboration, and occasionally being the first name on a paper. So all the software coming from universities came with source code included.

Early internet, being a network including a lot of those university computers, was also built on software that came with source code. Most of it in public domain.

However, as computers became smaller, cheaper, and numerous, a market for software became a viable business avenue. In the 1970s when computers became the size of a typewriter with a small TV on top and affordable for a small business or an affluent family there suddenly appeared a market for software like an OS to manage files, a word processor, a spreadsheet, a game, or like a billion other things than more than one person would want to use. Similar to Damascus steel, software developer didn’t want to lose sales and kept source code to themselves.

Personal computers exploded in popularity and so did software industry. Like any emergent market it was a wild west. People were trying to figure out how to make a living out of this new thing. But one thing everyone figured out quite fast is that it’s hard to sell software with source code. First, source code makes it easy to make copies of the software. Second, it’s actually useless because no one had any use for the source code, other than making free copies. One reason is that compilers, like any other software at the time, cost money—big money, too.

I have to point out that the idea of sharing was alive and well. It was so well, that Bill Gates kindly asked people to not share his BASIC without paying for it. Bill wasn’t very keen on other people sharing his product. At the time though it wasn’t clear where software even fits into the legal framework. It took some time to figure out but by early 1980s they decided that software is copyrightable (as a literary work), which solidified closed source binary software distribution.

In turn, some people became rather dismayed by this whole development. Things truly became awful. First you had to buy a computer, fiddle with it to even make it work. But then you also had to buy an OS for it to even make it barely useful. On top you had to buy software for every thing you wanted to do with it. Want to type some words? Buy a word processor. Want to crunch some numbers? Buy a spreadsheet. Play a game? Buy. Want to write your own software? You guessed, it—buy a compiler, or BASIC. Buy, buy, buy. Ugh…

But some people also remembered that not that long ago software was shared freely, with source code, too. And it was wonderful. So one day, one nerd came up with a clever idea: if software is copyrightable and licensing is the standard now, I’ll use your devices against you! And he came up with GNU license. His idea was to make source code the primary artefact, and the license would make everyone who wanted to use the software to also share their changes to the software, and almost everything that touches the software has to make its source code available, too! How devious.

For a little while it went about as one would expect. Nerds banded around this idea and built a bunch of stuff. A lot of it was useful. They had a C compiler, a debugger, a decent editor, they started working on an OS kernel. The work wasn’t moving too fast on the kernel side so when at the turn of 1990s Linux came about and happened to be almost instantly useful everyone (by everyone I mean the nerds) was very excited.

However, closer to the tail end of 1990s people started noticing that this Free Software was mostly sequestered to the nerddom. Like it’s been solid 15 years since the idea came around but none but nerds was into Free Software. Some people noticed that there’s basically 0 interest from businesses. You know, the organisations that have money and people. They didn’t use the software and didn’t help developing it. Some people figured that it’s the viral nature of GPL that made businesses stay away. No one wanted to accidentally infect their product and have to disclose their secret sauce for every competitor to see and copy. These people figured that if they used different licenses that were more friendly to businesses it would help adoption. On the marketing grounds, to differentiate themselves from the Free Software they called their movement Open Source Initiative.

Boy, were they right. When they picked licenses which were basically “do whatever, don’t sue me” adoption of open source software skyrocketed. I mean, whole categories of software became dominated by open source software. Mail servers, web servers—all almost 100% open source nearly immediately. After about 15 years, nearly all web browsers are open source. Governments run on open source office suites. After decades of expensive development tools, nearly all programming languages–be it an interpreter, a compiler, a debugger, or and IDE/editor—are FLOSS.

Turns out giving stuff away without requiring anything in return is extremely popular.

Compatibility Issues

There’s actually a reason it’s so extremely popular. You see, FLOSS is ripe for exploitation. Be it Free Software or Open Source, they both are built on a set of principles that are very noble and inspiring, are also incompatible with… uh… capitalism.

I want to clarify my hesitation. I don’t want to go into the whole capitalism bad/good thing. Let’s just accept that we all, right now, live in some form of capitalism. We have to get some money from wherever to afford some food, shelter, protection from elements, comfort, anything. Regardless of how you or I feel about it, it’s just how the things are. OK? Let’s, for the sake of the argument, assume that it’s a force of nature. I know it’s not really that but you can not change it, I can not change it, even we both together can not change it. Not anytime soon anyway. So let’s leave that discussion for another time.

So let’s start with money. Actually, let’s start with time instead.

If you’re reading this you’re probably involved in FLOSS somehow and you’ve heard that FLOSS take a lot of time. And it takes a lot of time for more than one reason.

First, it actually takes a lot of time to develop software. Like, software development is a full time job for a lot of people. But FLOSS is not only development. It’s also user support. And marketing. And technical writing. And sometimes graphic design. And project management. Sometimes DevOps. And a lot of times community management. And it can be a whole lot of other things.

Second, unlike all those things in the regular job environment there’s an asymmetric element. On a job almost all of those roles interact with only a handful of people and their pipelines carefully managed to hopefully not overwhelm valuable colleagues. But in FLOSS the few maintainers are completely exposed to the whole of the user base.

And third, no one’s prepared for the amount of time it takes. A lot of FLOSS is just someone’s hobby. A supermajority of FLOSS projects start as an experiment over a few evenings. It gets set loose on the internet. Someone finds it, likes it, writes a positive comment or sends a patch and it strokes Ego immensely. Almost universally it gives a massive motivation boost to keep working on it. Then a few more people join. You’ve got a small community around a shared interest. It feels awesome. You spend a few evenings a week working on it, maybe an occasional weekend. It’s all nice and pleasant. All is well. But then more people come. Maybe some of them are less technical and need more help with your software. Maybe some of them are more entitled than you feel appropriate. Maybe some of them are more abrasive than necessary. Or maybe they all are nice, intelligent, beautiful, and all around awesome but there’s just more of them than you can fit into the few hours you were spending on the project. The natural instinct is to spend more hours. More evenings and weekends. An occasional lunch break, too. But there’s only so many hours in a day. So you start thinking about making this your job.

It’s a very natural though. You already work on it as if it’s your second job. Your current job takes a lot of time: 8 hour, plus maybe an hour or two of commute. There’s obviously demand for your software.

So let’s talk about money.

A wise commenter on lobste.rs once told me “open source is not a business model”. I wholeheartedly agree. Moreover, I’m convinced that FLOSS is very at odds with any business model. Whatever business model you pick it requires you hurting the core software in some way to improve odds of selling whatever you sell. And every improvement to the software hurst your odds of a sale.

Are you trying to sell support? Well, no one’s buying support if documentation is too good. Are you going for open-core model? Now you have to withhold feature that otherwise could’ve been in the software itself. Consulting? Can’t do it if your software has no issues. Hosting? Really hard to find customers if it’s easy to instal, configure, and run your software. Any sort of business model incentivises worse FLOSS.

But that’s not all trouble. There's nothing stopping someone else taking the software and competing with you. What's worse is while you're busy developing software they can focus on a single aspect and do it better than you simply because they have more bandwidth. And while they’re earning money and outcompeting you, you’re still stuck with all the users who do not convert into a sale. After all, you’re the upstream.

I see you barely can contain yourself. I see the question in your eyes: but what about all the corporate FLOSS? Well, I’m glad you asked.

The way I see it—and I’m sure there are exceptions, but—it’s yet another form of exploitation. Some MBA saw an infinite supply of nerd who would work for free, on evenings and weekends, and they couldn’t pass. You hire a few engineers to drive the work into the right direction but you also get like 10x of work done for free. It’s absolute win.

There's a massive amount of money in FLOSS. An estimate of nearly $9 trillion floated around the internet not that long ago. That's like all of FAANG put together. But almost all of it is captured by the consumers of the software. The businesses that can use the software for free are basically subsidised by the people who do the actual work.

There are countless examples of maintainer begging for money while having user bases in thousands, sometimes even in millions. You might’ve heard of some, you certainly can find those examples. I’ll leave them out but if you ask nicely I might add some.

Now, let’s put money away, however little we managed to earn with FLOSS and look at a different aspect of… uh… human condition?

While corporations (or businesses in general) are amoral agents, at leas in the economic framework, people—both within and outwith them—operate according to some moral framework. Whether you agree with it, question it, or find it absolutely abhorrent, it’s hard to argue that there isn’t one for any particular person.

Economic drives are more or less universal—we all want to earn some amount of money, the amount and what we do with the money afterwards differs but the earning part is universal, it’s a feature of capitalism and there’s no escaping it. But morality pushes us in a very different directions.

A good quarter of a century ago one dude came up with a serialisation format–you might’ve heard of it, it’s JSON—and added to its license “The Software shall be used for Good, not Evil”. It’s undeniable that what is Good and what is Evil is a moral judgement. The author did the same with his JSLint tool. Now, I have to point out that this was done for lulz, to mock overzealous lawyers. According to the author all went as planned and about once a year he got emails from IBM asking for a special license without the clause. His reply was “I give permission to IBM, its customers, partners, and minions, to use JSLint for evil.” Mission accomplished: lulz were had.

I’m telling you about this for multiple reasons. One, this was considered somewhat bad taste in the FLOSS community. The clause was incompatible with any FLOSS license and some thought it made light of a very serious licensing business. And two, because recently I see more and more people trying to figure out how to incorporate morality into their software. People see a lot of things in the world that are not good at all according to their moral framework, they also see that software spreads wide and far and they don’t want to be involved in what they think is Evil.

WONTFIX by-design

The big issue is that FLOSS can not help any of these people.

You see, FLOSS is based on some foundational principles it deems untouchable.

Free software has Freedom 0: The freedom to run the program as you wish, for any purpose.

And Open Source has it in its definition: 5. No Discrimination Against Persons or Groups (The license must not discriminate against any person or group of persons.) and 6. No Discrimination Against Fields of Endeavor (The license must not restrict anyone from making use of the program in a specific field of endeavor.).

In simple terms, FLOSS can be used for Evil and you can't do anything about it.

Same thing goes for money. Free Software tries a bit to tell that you actually can charge for Free Software but in reality it also requires free distribution. Which is like… OK? You have to give it away for free but can charge for it? I can guess how well that works as a business model. Open Source is even more straightforward: 1. Free Redistribution (The license shall not restrict any party from selling or giving away the software as a component of an aggregate software distribution containing programs from several different sources. The license shall not require a royalty or other fee for such sale.)

It’s no wonder FLOSS hasn’t addressed any of these concerns. It can not do that without stopping being FLOSS.

Suboptimal Defaults

I think one of the main issues is that FLOSS has become the default. It’s what we choose when we don’t want to think about anything other than the software. Every major programming language package manager provides some sort of scaffold for a new project. All those scaffolds include a license and it’s some sort of FLOSS license. More often than not it’s MIT or BSD license.

When you’re only starting a new project you rarely have an idea what it would become. Will it be a failed experiment you spent a few hour on, or will it be user by a million people in two years. You usually start with an idea for the software and you’re only focused on implementing it.

But by the time license become important it’s already too late. By that time you already accepted a bunch of PRs under that license. You can try changing the license but you have to ask everyone who’s patch is merged to agree to relicense their patch under the new license. It’s hard enough to do that when switching from one FLOSS license to another. It’s impossible to do when you’re trying to switch to a non-FLOSS license. There’s always someone who’s not gonna have it. Even in situations where materially for the users nothing would change there’s still an uproar when a project switches to a non-FLOSS license.

Another issue is that FLOSS is kinda complex and no one’s teaching what FLOSS is. Many people, most, supermajority, almost everyone learns about FLOSS empirically, not by reading some definitions first. And because everyone has slightly different experience with FLOSS, and different world views, their head canon for what is FLOSS can slightly deviate from the official definitions.

And by slightly deviate I mean completely out of whack. Some people find community. It’s nowhere to be seen in the official definitions. Others find learning opportunity, skill honing. None of it in the defs. Yet others find validation. Zilch. Some just like to work for the common good, making the world a better place. OK, maybe a hit of this if you squint hard and tilt your head just right.

In any case all these are not part of the official FLOSS. You can have it without FLOSS. There are plenty of communities around proprietary (that is non-FLOSS) software. There’s a huge community around Photoshop, for example. Or Maya, or Autocad, or Windows, or MS Office as a whole, or Word or Excel in particular. Community is not a exclusive feature of FLOSS. Neither are any of the aspect listed above.

FLOSS can reject community, learning, collective development, and a whole bunch of other things we typically associate with FLOSS and as long the license is right and it’s upheld it still will be FLOSS.

The current model we converged on where we extract as much work out of few developers as possible and take the software for free and demand ever more from them is utterly unsustainable and has very little to do with FLOSS. That is other than FLOSS being unable to prevent this extraction without stopping being FLOSS.

Sacred Cow Slaughterhouse

OK, that’s a little too graphic even for me. Let’s try something different.

OODA

We observed the shortcoming of FLOSS. We actually did it quite early on in FLOSS history. There were attempts to fix it but there’s no definitive fix. We keep pointing at Red Hat and what not as a successful business built on top of FLOSS. But for every Red Hat there are literal millions of struggling FLOSS projects.

Another important observation is that FLOSS successfully positioned itself as a morally superior option. It mostly happened by accident. Historically FLOSS put itself into opposition to proprietary software, mostly developed by big corporations. Big corporations are greedy, deceptive, and just plain evil so everything in opposition to them must be generous, hones, and quite frankly all around good, right? It’s right in the name! It’s Free Software and Open Source. How Free and Open can be bad? Well, they’re not bad per se but as shown earlier they’re not universally good.

However, since FLOSS is in the category of morally good in most people’s minds it’s really hard to argue against it. This—somewhat tenuous-association works as a mental block for many people. “Yes, maintainers are burning out by the dozen and starving but you surely aren’t suggesting to leave this moral high ground, are you?” Why, yes, in fact I am.

Both Free Software and Open Source came about as a solution to a problem. They worked remarkably well. But they’re not without an issue themselves. The problems at this point are quite well documented.

Let me first orient you in the general direction of a solution.

I think the root cause of FLOSS impotence is non-discrimination.

The software access must be restricted to force a purchase in a capitalist environment. Likewise software use for certain purposes or by certain users must be restricted to accommodate any particular moral framework.

Deciding on a particular license I will leave as home work, dear reader.

I have decided for myself and it’s time to act. This is kinda why I’m writing this in the first place.

What’s Next

For you I suggest reevaluating your defaults when it comes to licensing. At the very least stop picking a FLOSS license by default. Leave this decision until later when you’d actually need the license. Do some research into alternatives. I will namedrop a few a bit later but it would be great if you did your own research. Let me know what you find.

For me, my next big project won’t be FLOSS. I’ve maintained a relatively popular FLOSS project for well over a decade now. I took it very easy, I never was in a dire need of money, and the load never was really overwhelming. But I have exposure. I know what it takes to maintain a big project. And if the project is big that is more effort than I’m willing to give away for free. You see, I’m getting old. I have a family, a couple of cats, friends, books, hobbies. I’d rather spend time on that than answering emails from random people on the internet. Don’t get me wrong, there are a lot of delightful people on the internet but there are also a lot of entitled, unpleasant, and outright rude people there, too, and I as a maintainer don’t really get to choose who’s writing me. So if it walks like work and quacks like work it'd rather pay like work, too. And I don't want to work 10x harder for that to happen.

At the same time, I want to bring in all those positive aspects we’re used to associate with FLOSS. I want people to be able to read the code and learn from it. I want them to be able to fix an issue with the code if they really need to and I’m unavailable for any reason. I want to project my moral code into the world and—maybe in a small way—make it better.

My current top contender for that is Bit Time Public License.

I like it because it’s in essence a commercial version of open permissive licenses like MIT or BSD. In spirit it’s very close to those “do whatever, don’t sue me” but also “pay me if you’re making a big buck with it”. For non-profits and small businesses it’s indistinguishable from an open source in most practical terms.

I want the source code to be available. I still intend to have some sort of community around the project. I most likely will accept contributions from the community but under some CLA. In my eyes a patch contribution is as much an offloading of maintenance effort as an act of altruism, but as you’re resigning some duties, it’s only fair you resign some of the rights. I haven’t found the right CLA yet but I suspect there’s one out there that fits. In addition to attesting the ownership and sourcing it should give permission to the project to use, change, and even relicense the patch, in perpetuity. But that’s details. If you happen to know one like it, please let me know.

Another good candidate—actually a set of candidates—is PolyForm License. It’s a set of licenses that apply in certain common scenarios. For example, if you’re building something and provide hosting service for it license prohibits other from hosting it as paid service for third parties, but permits all other uses so you can host it for yourself.

One aspect I find interesting is that there’s no license attestation when it comes to these licenses. Both Free Software and Open Source have officially blessed licenses and it’s a whole process to get a new license analysed and blessed to be allowed to call you project FLOSS. On one hand it’s convenient—you don’t need a lawyer to trust the general outline of the license. But on the other, these licenses are no different than your usual EUAL or any other commercial license: you read them, you accept them or not. The only bulletproof way to find out what the license actually allows or forbids is to go to court with it. GPL has been around for over 40 years and we still get nerds buzzing when it’s upheld (or not) in court. Because despite many words in the license, and even more words of the authors intent, the actual legal force of a license is unknown unless contested.

The reason I’m telling you this is that you can take these licenses as a basis for your own license. You can add your own restrictions. Say, you have a beef with military-industrial complex. You can add a “no war” restriction. Or you’re a vegetarian. You can add “no beef” restriction. You can do anything in your license and it doesn’t become less of a license. Remember that JSLint “no evil” restriction? Well, it wasn’t a FLOSS license but it was a perfectly valid license. It would be hell of a task to take apart Good and Evil in court to enforce the license but that’s another battle. Maybe make your restrictions less vague and it would be fine.

Instead of Conclusion

I want to make sure you don’t think I’m in complete opposition of FLOSS. I’m not. I think it has it’s place. I just think that the place is smaller than we try to make it.

I still intend to release some software under FLOSS licenses. I think it’s ideal for thing I don’t want to maintain. It was a one off task, or an experiment, or just quickly thrown together thing for someone else who’s not gonna maintain it ether. I think these are ideal cases for FLOSS. Just let it be in the world, without much attachment to me. If someone finds it useful—great. If someone learns something—very well. If someone gets inspired—excellent. But if I need to build a homepage for it, for me it’s a signal that the effort is above FLOSS pay-grade.

There are other situations where FLOSS might be the best options. For example, academic artefacts should be available under terms similar to the papers they accompany. FLOSS seems like a very close match. Software funded by public seems like a good fit for FLOSS. And of course, if you deliberately choose a FLOSS license because it exactly matches your intent, all good.

I’ve seen both BTPL and PolyForm Licenses used in the wild. There are not many of those projects yet but it’s a start. Like any change it happens gradually, then suddenly. So even if it seem futile, remember that there was the first GPL projects, as there was the first MIT project, and the first BSD project, and many other firsts. Now they’re everywhere. So keep your mind open and try new things to solve new problems. Or old problems that old things can’t solve.