Assumed Audience: Hackers and tech-oriented lawyers.

Discuss on Hacker News and Reddit.

Epistemic Status: Mostly confident.


Because of a couple posts, I was reminded of two semi-recent brouhahas.

When I originally came across them, I saw the FOSS purist side with righteous indignation. But I had also just started building a business, so for the first time, I understood the business side.

So despite my desire to post comments, I did not; I was uncomfortable with myself and my opinions.

Once I am aware of personal cognitive dissonance, it bothers me endlessly.

I am also prone to not being aware, of course.

I think I have come to terms with my thoughts and have solved my dilemma.

So in the spirit of Betteridge’s Law of Headlines, let me try to explain why the answer to the title is “no” and why Source Available is not bad.

tl;dr: It can give end users more control, not less, while still allowing authors to make money.

Free Software

We start with Free Software, which is defined by Four Freedoms:

  • The freedom to run the program as you wish, for any purpose (freedom 0).
  • The freedom to study how the program works, and change it so it does your computing as you wish (freedom 1). Access to the source code is a precondition for this.
  • The freedom to redistribute copies so you can help others (freedom 2).
  • The freedom to distribute copies of your modified versions to others (freedom 3). By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.

Where did these come from? Well, I’ll let RMS tell you in his own words:

Xerox gave the Artificial Intelligence Lab, where I worked, a laser printer, and this was a really handsome gift….It was very fast…but it was unreliable, because it was really a high-speed office copier that had been modified into a printer. And, you know, copiers jam, but there’s somebody there to fix them. The printer jammed and nobody saw. So it stayed jammed for a long time.

Well, we had an idea for how to deal with this problem. Change it so that whenever the printer gets a jam, the machine that runs the printer can tell our timesharing machine, and tell the users who are waiting for printouts…go fix the printer. Because…if you’re waiting for a printout and you know that the printer is jammed…you’re going to go fix it.

But at that point, we were completely stymied, because the software that ran that printer was not free software. It had come with the printer, and it was just a binary. We couldn’t have the source code; Xerox wouldn’t let us have the source code. So, despite our skill as programmers…we were completely helpless to add this feature to the printer software.

Now, I’ve known about this story since my introduction to Free Software more than 12 years ago, but something strikes me on reading it again: RMS wanted the source code to control his printer.

So I have a theory: when he formulated the Four Freedoms, his focus was on being able to control his hardware, not on freedom.

Freedom vs. Control

This theory, however, brought me at the problem from a different angle 50 years removed with history that clarifies.

RMS saw the problem as a lack of freedom; with the experience of five decades, I see it as a lack of control.

“But Gavin, those are the same thing!”

Not quite, but the difference is subtle:

  • The point of freedom is having liberty to do, to act.
  • The point of control is having authority over something.

In the context of this post, that something is our devices.

“You need control to have freedom, Gavin.”

Not necessarily. It does seem that way, but it’s the other way around: you need freedom to have control!

Imagine that you have a game. Imagine that, through no fault of your own, the source code of the game is available.

You now have the all of ingredients for control over your play of the game; you could change the source code and play the game as a god. Or a chicken. Or solve gaming’s greatest mystery.

But do you have the freedom to exercise that control? Do you have the freedom to do that? No, you do not.

That’s the difference.

At least in software.

RMS’s Mistake

When RMS articulated the problem, he did one thing right, but he made a slight mistake.

What he did right was recognize that freedom was essential for having control.

His mistake: he thought that unfettered freedom was essential for having control.

It’s an easy mistake to make; after all, my default thought would be that unlimited freedom was essential and that he was perfectly right.

This is where my cognitive dissonance came from; that default was the sham in my rumination.

But he was not right; it just takes some placid and precise peeling to unwrap that wrinkle.

Because the key is in pieces!

End User vs. Dealer

The first piece is in what kind of users exist.

In the 1970’s, there was only one kind of user: programmers.

At the time, buying software was rare; instead, it was common to pass it around freely between colleagues and other peers, who were, by and large, other programmers. Or other computer priests.

So users were, in general, all distributors. And they wanted nothing else than to use the software. In other words, making money from software, from selling it, was not a big thing.

Obviously, writing software for pay was a thing; I’m talking about selling software through distribution.

Things are different now. Making money became a big thing. This means that there are different kinds of users:

In this post, a “dealer” is roughly someone who makes money from software.

And yes, the subtle connection to drug dealers and car dealerships is intentional.

And it turns out, to have control, they need freedom for different things.

End users need freedom over their device. In addition, distribution is incidental to helping others; they only care about sharing so that other end users also have control over their devices.

The fact that end users can be distributors by sharing is why I use “dealers” instead of “distributors” for the other kind of user, as well as why I use “sharing” instead of “distributing” in the context of end users since “distribution” has a definition in commercial law.

On the other hand, dealers need freedom over the software itself in order to make money from it.

The question then becomes: are both kinds of users important?

RMS thought so. In the Free Software Definition, RMS specifically says,

We want to invite everyone to use the GNU system, including businesses and their workers. That requires allowing commercial use. We hope that free replacement programs will supplant comparable proprietary programs, but they can’t do that if businesses are forbidden to use them.

I believe he was wrong; 50 years of history points to a simple fact: dealers hate the AGPL, one of the strongest Free Software licenses. They won’t use the software if they can avoid it.

Why? Well one line from that first link is instructive:

…the AGPL is absolutely not free in any meaningful sense for developers.

(Emphasis added.)

This is a stunning admission; the article claims that the strongest license removes freedom for “developers,” which is a code word for dealers in this context.

“Okay, Gavin, but that seems frivolous.”

On the contrary, it is momentous!

Think about what freedom the AGPL removes: it removes the freedom to not publish source code.

“Sure, but that’s a tiny thing, Gavin.”

If it was a tiny thing, companies wouldn’t have strong policies against it, so it must be a big thing to them.

And why is that? Because that freedom is what allows them to take control from end users by not publishing source code!

Bruce Perens, who might know a thing or two about serving end users, said,

Open Source [and Free Software] has completely failed to serve the common person. For the most part, if they use us at all they do so through a proprietary software company’s systems, like Apple iOS or Google Android, both of which use Open Source for infrastructure but the apps are mostly proprietary. The common person doesn’t know about Open Source, they don’t know about the freedoms we promote which are increasingly in their interest. Indeed, Open Source is used today to surveil and even oppress them.

This is why RMS made a mistake: I believe he wanted to protect end users the most, and he thought that welcoming commercial interests into the fold would mean benefits would benefit end users. However, despite trying to welcome commercial interests, they rejected his vision so that they could oppress end users!

Sadly, even I subscribed to same poisonous view as commercial interests! This made my opinion a Frankenpinion; I wanted Free Software to win, but I believed that copyleft was holding it back.

And I was vocal about it! On an early version of this page, I said,

In my opinion, virality is parasitic and has caused people to use closed-source software instead of FOSS alternatives when those alternatives were licensed under the GPL and AGPL.

As of the publication of this post, that quote is still there, but it will change soon after I finish crafting those licenses and their FAQ pages.

Well, I was wrong; virality is good for end users because it forces dealers to preserve freedom for end users.

I think this is why RMS and his Free Software Foundation are so vocal about copyleft.

So it is obvious that we must choose between control for end users and control for dealers.

I choose end users. Autocratic dealers can go to /dev/null.

Principles, Not Freedoms I

So if the foundations of Free Software, the Four Freedoms, are not quite right, we need to reconsider.

Instead of four freedoms, I would like to propose two principles:

  • Principle 0: End users must have enough freedom to control their devices.
  • Principle 1: End users must have enough freedom to help other end users control their devices.

Principle 0 is obvious, but Principle 1 is just as important; if end users do not have the freedom to share, that is a problem for other end users, most of whom will not be programmers.

Sharing is critical for the freedom and control of end users who are not programmers, who deserve just as much as programmers do. Therefore, Principle 1.

Source Available?

That finally brings us to Source Available software, of which Wikipedia has a solid definition:

software released through a source code distribution model that includes arrangements where the source can be viewed, and in some cases modified, but without necessarily meeting the criteria to be called [Open Source].

So what’s Open Source, a term already mentioned?

Like Free Software, it’s a carefully honed definition, which is too long to put here.

But that definition is also controlled by an organization.

Open Source is like Free Software, but more broad. Source Available is when the source is “open,” but people decide that the license does not meet the Open Source Definition.

But here’s the key: Source Available, if it’s any good, still gives end users freedom and control!

But it does have to be good, which means to follow the principles above. This means that Source Available has to:

  • Allow the end user to modify it and use modified versions.
  • Allow the end user to share it, including modified versions.

Unfortunately, not all Source Available software does this, so we need a specific name for software that does.

Could we use the term “Open Source”? Ha! Fat chance!

The biggest cause of the brouhaha I mentioned is that Sentry called their code Open Source when it did not fit the Open Source definition.

To be frank, I’m actually on the side of the purists here; we have a widely accepted definition, so that definition should be respected.

Yes, even if we, as business owners, do not like the definition. And even if we want the goodwill that comes from embracing Open Source.

If you were wondering, the same care that makes me avoid “Open Source” is the same care that chose “dealer” over “distributor” above because “distributor” is a definition in many FOSS licenses.

So let go of the goodwill; we can find another term. We might even find one that already has fantastic connotations.

In fact, I think I have one!

You see, both things that Source Available software must be to be good include being modifiable, so I leaned into that by borrowing a term from gaming: moddable.

But that’s not a single syllable; Free Software became a mind virus with a single syllable word, even if it needs “Software” on the end, and even if it has to be explained.

But I can make mine a single syllable in the same spirit by adding a common suffix to make the term “modware.”


Software that you can modify (“mod”) and share (because gamers share their mods).

I did not use “mod” because the gaming community already uses that term for the modifications themselves, and I think they deserve to keep that term since they came up with it.

Plus adding “ware” denotes that it is software and has the same flavor as terms like “shareware” and “freeware.”

And if that’s not descriptive enough for you, I guess we can try again.

Free and Open Source Software is a mouthful, but it has an easy abbreviation: FOSS.

Since this category includes software whose source is available and moddable, what if we used “Source Available Moddable Software”? Then the abbreviation would be SAMS, which is easy to say, easy to remember, and not quite an actual word.

Don’t like “Moddable”? It can be changed to “Modifiable” without any loss.

I vote for either of these terms, or both, but if someone does better, it does not matter; we just need one term with good connotations and a meme-like quality.

Authors vs. Redistributors

That brings us to the second piece of the key: the two kinds of dealers, which are authors vs. redistributors.

“But Gavin! Authors are distributors!”

Well, yes. That’s why I specifically said redistributors.

Roughly, authors are the original developers of a piece of software, and redistributors are any distributors that are not authors.

And here is where we can see how RMS made his mistake: he was an end user and an author, and as an author/distributor, he wanted distribution freedom too.

But the needs of authors are different from plain redistributors.

How different? Watch the following video 18:56 to 20:32 (or use this link):

In essence, authors have two costs: software development and business development. Under FOSS, redistributors only have one: business development.

This means redistributors outcompete authors, in a phenomenon Evan Czaplicki calls “The Jeff Problem” or “Getting Jeff’ed”:

So we’ve got this Open Source Definition where Google, they give their stuff away to Microsoft; that works. And then we have this other thing where you have to do the development cost, you have to do the cost of business, but they have to do the cost of developing business too.

But they’re Amazon, so they say, “Oh, you want to do hosting? That’s cool. We’ll just do it more and do it to more people.”

And [they] start to cannibalize your business.

And…It’s not just Jeff; I can get Jeff’ed by anybody.

So it turns out that certain authors need protection from redistributors just as much as end users need protection from dealers!

Principles, Not Freedoms II

We are in a terrible situation, where end users and authors are not safe from middlemen, the dealers who are not authors.

This is unsustainable.

Putting rose-colored glasses on, I personally think that this problem is what Sentry was trying to fix with the FSL. And what SourceGraph tried to fix. And why GitLab is open core.

Unfortunately, as software engineers, and not social engineers, these companies failed to fix the problem and only stirred up stinging zingers.

So as a fellow programmer, let me throw my hat in the ring and fail too because we need a concept that protects authors and end users from middlemen dealers.

Let me add two more principles:

  • Principle 2: Middle men should only receive the freedom that end users need.
  • Principle 3: Authors may reserve as much control to themselves as possible, as long as Principle 0 and Principle 1 are not violated.

Principle 2 should be self-explanatory.

However, dropping Principle 3 on the industry might be like dropping a MOAB into a well since we are so used to Free (as in freedom) and free (as in root beer).

But we have a funding problem in Open Source.

And legitimate companies that try to open their source get Jeff’ed.

So let me give a warning to the industry as strongly as I can:


If companies and programmers refuse to pay, software will only be opened by companies that can throw money away, and there are not many of those companies.

And they don’t care about us anyway.

To keep software open, we must let authors make money and prevent dealers from eating their lunch.

How can we do this? By accepting licenses that meet the SAMS definition and that may not be Open Source (by the Open Source Definition).

And by “accepting,” I mean treating software with those licenses as equals with Open Source.

The definition of SAMS is purposefully wide; it gives authors wide latitude to choose what works for them.

And what may work?

Are those options wrong?

Despite my rabid support for FOSS, I do not think there is anything wrong with this; authors have a right to put food on the table with their work, and I think it can be done while respecting end users.

The only ones who get “shafted” are the middlemen dealers who do nothing but cannibalize software that they still get for free!

Oh, won’t someone think of the poor dealers! 😑


“But Gavin! Those licenses violate the Four Freedoms and the Open Source Definition!”

Yeah, so?

Sure, you can’t run a program for any purpose, but that’s the only one of the Freedoms that it violates. And you can still run a program freely as an end user.

And sure, now authors can discriminate against certain groups of persons known as companies, and now they can discriminate against certain fields of endeavor, like business ones. But they can’t discriminate against end users, including you.

The only reason you would care is if you’re afraid for your company.

And the only reason you would be afraid for your company is if it’s a cannibal.

If that’s the case, I think the problem is your company, not the concept of SAMS.

I am willing to sacrifice cannibals for the greater good of control for end users and money for authors.


But there is no such thing as a free lunch or a free ride.

Unless you’re a cannibal dealer with FOSS.

There is one problem with non-FOSS SAMS, and I won’t even try to minimize it by claiming it’s minor; it’s not.

The problem: contributions.

If you have a company and want to open your code as modware/SAMS, you may have to give up sourcing contributions from end users.


Remember, I am not a lawyer.

The problem is that if you accept user contributions, you don’t own the copyright to those contributions. If your software is already modware, you may be fine if you stay that way.

However, if you decide to move from FOSS to SAMS, or even from SAMS to FOSS, you can’t without contacting every one of those contributors to ask for permission.

And if you don’t get it, or can’t contact them, tough luck.

Another option: you could get those users to sign a CLA, but end users are gunshy about them now.

The final option is to not accept contributions.

In other words, those modifications that your end users make? You can’t use them yourself.

This may catastrophic, or it may be nothing. You just have to be aware and choose if user contributions are more important than maintaining your advantage over cannibals.

In my case, I don’t play well with others and can’t read others’ code. And I want to relax my license over time. The choice is obvious.


Now, I’m sure you have noticed something: SAMS is a superset of both Free Software and Open Source, so any FOSS is also SAMS.

Well, sort of. Some FOSS turns proprietary because it’s not copyleft, or is provided as a service.

This is why copyleft should be default: it prevents dealers from altering the deal for end users.

But any FOSS that is actually in end users’ hands in source form is SAMS.

My Bet

Words mean nothing without action, so I am going to make a bet.

I am betting that SAMS/modware can be widely accepted and that they will not reduce end user freedom while saving authors from getting Jeff’ed.

So I am going to put my code under a SAMS license, one of my own making.

As of right now, I don’t have one, but before I release my software in a few months, I will add a noncommercial license and get it checked by a lawyer along with the others. And then my code will be under that noncommercial SAMS license.

Is it a risk to my business? Absolutely; potential customers could look at the license and flee.

But “all progress depends on the unreasonable man,” so I will be unreasonable and stick to my bet, even at the cost of my future business.


Of course I want to insist that I am right. Nevertheless, it is not on me to say; the success of my ideas in this post depends on the industry, on you.

Do you want me to be right? Do you want me to be wrong? Act like your choice, and we will see with time.

But beware lest you lose what you have to spite what you hate.