I don’t see how this is fair. The license can be summed up as: “Contribute your work, I keep the money. Forever.”
It is basically a source view license, similar to many used by Microsoft. (https://en.wikipedia.org/wiki/Shared_source)
Sourcegraph CTO here. Our goal with Fair Source is NOT to have people in the community write 90% of the code and then profit off their hard work. Rather, it’s to make the code that we’ve written for Sourcegraph publicly available for all to view (rather than keep it closed off). If a user notices an issue or wants to create a small enhancement or plugin, they can do so, instead of filing an issue and waiting for a response. But we are also glad to receive issues and will resolve them as quickly as we can. Retaining the ability to sell the core product means we’re incentivized to make the core product as good as possible, all while having the source code publicly available.
That’s precisely what I am saying: it’s for viewing. That’s okay, but not novel and was heavily criticized when Microsoft did it - for good reasons. The software doesn’t contribute to the commons.
That’s all okay and you are perfectly within your rights to do this.
There’s one thing I find rather ugly though: the appropriation of the term “fair”. You’re on a high horse there.
With all the recent open source authors losing it and quitting open source, are they really on a high horse?
We place too much burden on open source authors. I think your summary, “Contribute your work, I keep the money. Forever.” is unfair. In reality they will be producing the vast majority of the work. How many people actually contribute to someone else’s open source project, enough that they could feel entitled to money for their contributions?
All of this complaining is the same bullshit people cite when leaving open source. These  posts are even highly upvoted here on lobste.rs, and yet when someone tries to solve this problem for themselves our reaction is to bitch about it? For fuck’s sake.
By picking the term “fair” for them? Yes. “public source viewing licence” (PSVL) would been a much tamer term.
That is okay, but the result is not open source and not free. It cannot be reused. Even the FAQ for the license says so. As I said: I am fine with the terms of the license, but it should not pose as an open source or free license. Contributing to the commons is an important part of open source. A problematic funding situation that needs to be solved comes with it and I don’t want to question that.
I’m sorry, but I don’t see how we are even discussing the same thing. Handwaving that everyone is “bullshitting” when they don’t agree with certain solutions isn’t helping either.
So, users are free to contribute fixes to their own problems, but can still pay full-price for the privilege!
More seriously, why not dual-license under a viral copyleft (say, AGPL3) and a normal commercial license? That’s what id did.
I want to reiterate the fact that we don’t expect users to fix bugs or issues on their own. Our team is fully committed to responding to feedback and making Sourcegraph into the best code host possible.
The reason we didn’t do a dual-license model is because we wanted to retain the ability to sell the core product to companies. This preserves the incentive for us to invest in improving the core product and technology.
You can still sell the dual-licensed product…especially if it’s with a super-viral copyleft license. You just explain “Hey, if you don’t want to be legally liable to disclose your entire product’s code, buy our commercial license”.
The people that would ignore that and not pay would do the same under the proposed license.
There are many examples of dual-licensed software which work exactly this way. Sidekiq is a recent example, which makes the core functionality, which is good enough for a large percentage of users, free under the LGPL, and has a “Pro” and now an “Enterprise” version which adds significant feature improvements to the library and is “commercially” licensed.
MySQL is, of course, another major example of this.
Indeed, MongoDB uses dual-licensing to what seems like a great success!
It seems fine to me, but more as a way to encode business practices in the license. It seems like what I’d want if I were writing software that I was perfectly cool with hobbyists and small shops using, but would want enterprises to be explicitly on the hook for payment.
What I’m interested in is whether or not any enterprises will actually touch software licensed in it.
Well, but one of the core ideas of open source and free software is contribution and collaboration.
I would see no reason to contribute to such a project.
The license however does allow you to make your own changes to the software, which is a huge reason why big companies prefer FOSS, they can change stuff to their own means as they need to for their own needs.
How frequently does that actually happen, though? For companies that are not in the software business, I would say just about never.
I don’t know how often it happens in general, but I’ve seen companies make changes to OSS code quite a bit. It usually only gets publicized when they are caught violating licenses, or contribute back a huge amount of code.
In my experience, most companies make relatively small changes and obey licenses, so they don’t raise much interest.
For example, if a company has an internal application with a custom logging system, they might modify the OSS libraries they’re using to use their logging system. Since it’s an internal app, the GPL doesn’t require making the modified source available, and other licenses are even less restrictive.
I guess some kind of bounty system that would allow you to target individual bugs could be a good way for companies of paying for work. Or whatever money received from commercial licences going on bounties
This just seems like shareware with visible source code. Whether that’s fair depends on the arbitrator.
I get what they’re going for, but defining things as loosely as by “people using the code” is fairly meaningless. What if I have zero users because people don’t use a particular system? Can I then install it on 1000 servers or only 25? What if the code (on a different system) sends an email alert to 1000 people, are they all “users” or just the person that actually interacts with the system?
This connects to another issue with new/unfamiliar licenses: the concern that the protections or guarantees they claim to provide are not actually ensured. The advantage of a familiar license is that the language has been vetted by a number of entities, and you can rest reasonably assured that it does what it claims. I do not know if this particular license has any problems with the assignment of rights or anything like that, but I do not have the same level of assuredness I would with a more usual license.
I think part of what journeysquid was trying to point out is that this license is worded so imprecisely that it’s impossible to know when you’ve violated the terms.
Also, can I split my company into 25 people groups to go around the 25 people limit?
Oddly this was sort of what I was thinking, have venn diagram groups of teams (which actually fits with Conway’s law) and just end run around the user limit w/ a containerized sourcegraph for each team.
I think a title that managed expectations better would remove most of the objections to this license. The idealistic word “fair” gives the wrong impression of the license being an idealistic open-source-compatible license.
The problem is I can’t think of a viable alternative title to suggest. The title should say something about the differences from other licenses while still being concise. All I’ve got so far are “Individual-Friendly Source View License” or “Small-User Editable Source License”.
This license is harder to summarize than other licenses because it mixes the rights model with the pricing model.
Creating a new license creates more buzz about the license than the product. At least buzz measured in raw number of comments.
The model that I want to have is one in which companies are expected to pay you to fix bugs if they don’t want to fix it themselves. I think that licenses like these are incredibly shortsighted in the sense that they assume that producing software is the difficult part. If anything, it is maintaining complex software that is costly and dangerous.
(One of the creators of Fair Source here…) Fair Source is not an open-source license. It is intended to be an improvement over closed source (GitHub, Bitbucket, etc.) and open core (where often the important bits are closed source).
improvement over closed source
Improvement by what measure? From the page:
Releasing a product’s source code makes it more valuable to customers by enhancing extensibility and building trust.
I don’t see how those properties are enhanced by this kind of license. Extensibility is provided by good modularization and useful APIs and well-defined plugin points (along with good documentation). Trust is built via positive exchanges over time, it’s not instantly provided because I could (though won’t) comb through the code.
Yet another license… It’s alarming how certain topics (Open Source licensing currently, Unicode handling and others in the past) seem to urge users to come up with half-baked solutions which probably won’t stand a chance “in the real world”. You can measure it by looking at trending topics at lobsters.
You probably know my opinion of the GPL, however, this “Fair Source License” makes even less sense and it smells a bit fishy, especially if we take in regard different jurisdictions in different countries.
Many lawyers worked on the GPL, and it can be considered “audited”. How many people worked on this license here?
Also, as others pointed out, it’s not a fair license. Fair means to treat everbody equally, including John Doe on the one and Google Inc. on the other side. Apart from the WTFPL, BSD- and ISC- licenses, there are no real fair licenses around.
This seems to me inferior compared to the “Open Company License” that I know the E Text Editor tried out many many years ago: https://en.wikipedia.org/wiki/E_Text_Editor#Source_Release
To put an arbitrary limit on the number of unpaid users allowed before one needs to pay seems unnecessary complex to me. To instead do like the “Open Company License” and just in addition to a basic BSD-style license forbid the removal of the licensing module from the code sounds much simpler to me:
Any redistribution, in whole or in part, must retain full licensing functionality, without any attempt to change, obscure or in other ways circumvent its intent.
Here’s the archived blog post from that announcement in 2009: https://web.archive.org/web/20120104190748/http://e-texteditor.com/blog/2009/releasing-the-source