1. 25
  1.  

  2. 22

    To release a nonfree program is always ethically tainted, but legally there is no obstacle to your doing this. If you are the copyright holder for the code, you can release it under various different non-exclusive licenses at various times.

    The “ethically tainted” doesn’t resonate with me, I think this licensing model should be encouraged. I will admit I am kind of biased on this because I work on a for-profit GPL-license project.

    The ethical taint comes from the idea that the idea that, paraphrasing RMS, copyleft only works because of copyright and is only needed because of copyright. A world without copyright cannot support the GPL, but it would not be necessary to use the GPL because code would already be quite free. To release a non-free program is to attempt to create an artificial scarcity of that program’s source code, an ethically questionable action at best and a step towards monopoly and market distortion at the worst.

    I’m sure that you know what folks say about trying to convince folks whose income is dependent upon a particular worldview.

    In the open-source communist utopia, everything is open source and nothing is for sale, so dual-licensing doesn’t fit that particular utopia. But we live in the real world, where money makes things a bit more complicated, and in the long term, dual-licensing might be better than equal-rights open licenses. Well, developers have to eat.

    Our society could afford to feed everybody. We choose as a society to have a world where people starve, where food is not affordable, and where households are stratified socioeconomically into classes. Similarly, we choose whether or not to share code. However, that doesn’t invalidate the ethical gradient; it’s not like both choices are equally reasonable and defensible.

    Also, there’s a bit of a paradox here for folks who have careers built upon Free Software. The portfolio I’ve used throughout my career is built directly from my Free Software contributions. My ability to command a salary is derived directly from my reputation contributing to community projects.

    When it comes to license like MIT and BSD, that impose no restrictions upon usage, where the “owner” doesn’t exist, it’s interesting to look at who release projects under those licenses:

    • Students or hobbyists, people creating software for fun, notoriety, and experience.
    • Very large companies (Facebook, Google, Amazon, Uber) or government & donation founded organizations (Universities, Public Research centers, software foundations such as GNU, Apache, and LSF)

    Folks go from the former to the latter. The most famous example from software I use daily is probably Linux, but vim is another good example. Indeed, vim’s history includes an employee at a very large company using their spare time to work on hobby projects.

    It is possible to view code ownership under a more collaborative, imperative model, where the point of code ownership is to maintain the code and keep it viable. From this perspective, many codebases, including Linux and CPython, operate under a sort of polder model which combines community contributions, academic research, business-driven optimizations, and user-desired feature work into a single holistic effort to maintain source code.

    Why can Nvidia assign engineers to dozens of open source ML and game-engine projects?

    This is an excellent example of particular situations which need to be examined. nVidia does several specific additional things:

    • nVidia deliberately encourages hardware engineers to ship extra features
    • nVidia publishes lots of extraneous GL extensions
    • nVidia embraces and extends the GL specification

    From this perspective, nVidia assigns dozens of engineers to tiger-team their GPU support in game engines as part of a larger strategy to ensure that nVidia’s offerings are always able to lock in customers by offering a featureful experience which other vendors cannot offer.

    This is not the only possible strategy. When AMD acquired ATI, they started publishing AMD/ATI hardware information, which led to the Free Software community writing several drivers for their hardware. (I wrote one-and-a-half of those drivers.)

    The only problem that remains here is the fact that you can’t chain GPL projects. That is to say, one can’t use GPL code in their own double-licensed GPL code, but there are workarounds for that (e.g. isolating the GPL dependency and open-sourcing the changes to that alone). Still, this seems like the kind of problem that could be fixed by an off-shoot of the GPL meant for just this use-case.

    This isn’t a problem for us. This is certainly a problem for your employer. But this feature of GPL is not just a nuisance to employers; it’s essential to maintaining the Four Freedoms.

    Currently, a company that wants to include GPL into their project has two options…

    There’s three, actually. The third option is to take a hard look in the mirror (at the corporate level) and realize that they can just pay people to write code. This might sound cold, but Google is an example of a very large company which avoids the GPL by re-implementing whatever is required, up to and including libc.

    But what if the “pay the maintainer a small sum” option was available. Wouldn’t the liability afraid giants look towards this much more favorably than either of the other 2 options?

    You’re so close and yet so far! For liability reasons, corporations are increasingly forced to employ people like this, rather than keeping them at an arm’s-length or contracting distance. And that brings us to the previous point.

    I’m going to close by noting how you talk about (little-c) communism, because I think that it is worth exploring.

    In the open-source communist utopia, everything is open source and nothing is for sale, so dual-licensing doesn’t fit that particular utopia.

    Curiously enough, this is also the case in a capitalist utopia! Suppose that markets are efficient and that capital investment is available to everybody (the cost of capital has zero/negligible premium). This creates a capitalist-libertarian paradise where anybody who participates in a market as a buyer can also immediately become a seller in that same market by offering to sell what they’ve already purchased. (If this sounds fanciful, consider how existing stock markets work.) Now, consider the market for any particular piece of information. The only reasonable equilibrium is zero, and so the price will slowly fall; each buyer of the information becomes a seller and increases supply while lowering demand.

    This is not just a theoretical exercise; the introduction of the printing press completely changed Western Europe, and its only action was to lower the capital investment required to duplicate information. Bibles produced in the Middle Ages and earlier were extremely expensive; with printing technology, Bibles became so much more common that today, they are given away for free and people often turn them down as (monetarily) worthless!

    What, exactly, is the problem with communist utopia? You seem to think that it will result in people starving, but people are already starving.

    1. 2

      The ethical taint comes from the idea that the idea that, paraphrasing RMS, copyleft only works because of copyright and is only needed because of copyright. A world without copyright cannot support the GPL, but it would not be necessary to use the GPL because code would already be quite free. To release a non-free program is to attempt to create an artificial scarcity of that program’s source code, an ethically questionable action at best and a step towards monopoly and market distortion at the worst.

      Even so, it still seems preferable to closed-sourced code. But, my main argument is that dual-licensing GPL is probably better than using something like MIT or pure GPL if our goal is moving towards a more free environment. If a free environment can be or is reached, the need for a license goes away, or at most a license is simply a requirement for citing the authors (as in BSD style licenses)

      This isn’t a problem for us. This is certainly a problem for your employer. But this feature of GPL is not just a nuisance to employers; it’s essential to maintaining the Four Freedoms.

      I kind of agree here, from my perspective chaining is great. It’s just that it might lead to rather complicated contract chains when dual licensing. It might also stop dual-licensing if some component down the chain isn’t dual-licensed, but in practice, this isn’t a problem since so little software is released under GPL, and even less so under more restrictive versions like AGPL.

      But there’s nothing to say one can’t distribute money from dual-licenses downstream to other dual-licensed GPL code being used by the project.

      It is possible to view code ownership under a more collaborative, imperative model, where the point of code ownership is to maintain the code and keep it viable. From this perspective, many codebases, including Linux and CPython, operate under a sort of polder model which combines community contributions, academic research, business-driven optimizations, and user-desired feature work into a single holistic effort to maintain source code.

      This can be true for a few projects, but it doesn’t seem to be the case for the vast majority of projects. Especially once you get into domain-specific stuff were only a few hundred or thousands of people are using the library, as opposed to it running on more than half of the Turing complete hardware on the planet.

      There’s three, actually. The third option is to take a hard look in the mirror (at the corporate level) and realize that they can just pay people to write code. This might sound cold, but Google is an example of a very large company which avoids the GPL by re-implementing whatever is required, up to and including libc.

      That’s actually true, I guess, but it seems like the worst of all possible scenarios and impractical for all but a few companies.

      1. 1

        The big problem with dual licensing GPL + proprietary is that anyone who accepts the GPL is then free to make changes that are GPL-only. If enough people do this, your proprietary version will lag in features and it can’t adopt the GPL’d changes unless the authors are willing to assign copyright or sign a CLA that allows relicensing. If your project actually gains traction and a thriving ecosystem, the GPL’d version will end up displacing your version because everyone will contribute to it and can pull in your changes but you can’t pull in theirs.

        To add another anecdote to @shazow’s, I have also been paid to write permissively licensed alternatives to existing GPL projects by companies that didn’t want to comply with the GPL. For small libraries, it’s relatively cheap and if the permissively licensed version is useful it will get external contributors and is cheaper than maintaining a proprietary component. Large things are only feasible for a big company to do it but there’s also a greater incentive.

        1. 1

          There’s three, actually. The third option is to take a hard look in the mirror (at the corporate level) and realize that they can just pay people to write code. This might sound cold, but Google is an example of a very large company which avoids the GPL by re-implementing whatever is required, up to and including libc.

          That’s actually true, I guess, but it seems like the worst of all possible scenarios and impractical for all but a few companies.

          I acknowledge that this is an anecdote but I have personally witnessed tens (maybe even hundreds) of examples of people re-implementing code to avoid having complying with GPL/AGPL/etc license terms of a dependency. I can think of a few examples that I’ve discussed with peers just last month.

          I can’t think of a single example in my entire career where an individual or company decided to change the license of their codebase just to comply with the license of a dependency.

          This spans personal projects, startups, and big companies like Google. In fact I have done it myself on several occasions, and nearly all of my work is MIT licensed. Across the spectrum, I have never seen a company choose a copyleft license because they got tricked into it by a dependency rather than because they felt aligned with the ideals of that license.

          I agree that this is the worst case scenario, and I submit that it also by far the most common scenario.

      2. 8

        We’re going to start seeing more licensing along the lines of - Use it for your project as you like, but you can’t use it as a for-profit hosting service. This has been a huge fight with Elastic and Amazon, where Amazon offered hosted elasticsearch in AWS causing harm to Elastic that had their own cloud - so Elastic changed their license to prevent this, and Amazon went out of their way to make the “open distro” with them supporting an equivalent API in a permissive license.

        Redis protected themselves here, and others are starting to do so as well. It’s very likely we’ll see adoption of a limited/permissive license soon (like a modified MIT/APL/BSD) that folks can use without worrying that a cloud provider will swoop in and make money off the backs of small open source creators backs.

        1. 3

          Yeap, the odd thing is that Redis & elastic seem to have gotten a lot of bad press out of it. Which to me seems insane, since it was question of not giving amazon and google a free hand to run them into the ground.

          1. 1

            What is the bad press about? Like what are they saying is wrong about the change? Just that it’s not in the “spirit” of free software?

          2. 2

            Yeah, this does seem like a necessary change for a lot of free software projects. The software is free (as in beer), but someone (ideally the original creators) still owns and “controls” its use.

            1. 2

              It’s expensive to write, it’s free to copy. If your business model involves writing the software for free and then hoping you have some way of recouping that cost later then you may need a new business model. If your software works fine and needs no further modification, what do you lose by letting Google / Amazon deploy it at scale? If it needs updates / bug fixes / security updates, then those large deployments are a great place to look for people willing to fund them. If you stop producing them, then people who have built critical infrastructure on top are going to suddenly realise that was a very expensive mistake.

              1. 2

                I mean, it’s more so than free as in beer, since it’s also open source.

                If anything, it’s more of the opposite, the software is always open, but not always free (i.e. not if you want to use it in a proprietary product).

                1. 1

                  Yeah, that is a good point. Open is the right word there. It makes sense to me to do this.

              2. 2

                This has been a huge fight with Elastic and Amazon, where Amazon offered hosted elasticsearch in AWS causing harm to Elastic that had their own cloud - so Elastic changed their license to prevent this, and Amazon went out of their way to make the “open distro” with them supporting an equivalent API in a permissive license.

                This is not what happened. Elasticsearch as a commercial offering was always dual open-source and closed-source, where the licensed part are Elastics “value-add” features like access control. Elastic at some point opened op the closed-source parts under a commercial license and added them to the main repository.

                Amazons complaint and reason for forking their own distribution was that Elastics main repos contains commits that apply to both parts of the codebase. They started to maintain a clean source version. It also ships with some open source addons out of the community. https://opendistro.github.io/for-elasticsearch/

                (That was a very rough summary)

              3. 5

                Dual licensing a way in which the “owner” of the code ends up in an advantageous position compared to other users.

                That’s exactly why it’s ethically tainted. The FSF, the GNU project and the free software movement are about ensuring user freedom, universally. If dual licensing means restricting user freedom, then I understand that they would not want to encourage it. Of course, since the GPL is a legal document, that tries it best to subvert copyright law, it has it’s limitations.

                So would it not be nice for open source if one can bring profit motives into the whole thing?

                “Open source” has never had an issue with this, it is a business model after all, not a moral principle. So I don’t see anything new about that kind of an idea.

                1. 2

                  That’s exactly why it’s ethically tainted. The FSF, the GNU project and the free software movement are about ensuring user freedom, universally. If dual licensing means restricting user freedom, then I understand that they would not want to encourage it. Of course, since the GPL is a legal document, that tries it best to subvert copyright law, it has it’s limitations.

                  How is user freedom being limited in this case?

                  What I’m talking about here is basically a model where a “standard” user still has the same amount of freedom (under GPL), it just adds another tier of user that has more freedom (because they can operate outside of the GPL).

                  It does create inequality among users, but a GPL user still gets the exact same bargain as they would with a normally licensed piece of software.

                  “Open source” has never had an issue with this, it is a business model after all, not a moral principle. So I don’t see anything new about that kind of an idea.

                  Agree, wasn’t necessarily trying to say something new here, more so I was trying to summarize the idea behind a specific business model that many people might not be aware of, which I think is fairly ethical compared to that most people work for, thus I’d hope it would become more popular (at least among the demographic which currently has a choice between no working at all or working on proprietary code)

                  1. 3

                    The “user” who purchases the proprietary license is an entity that is purchasing the ability to restrict what the buyers of their derivative works can do with those derivative works. If they didn’t want to restrict their buyers’ freedom, there would be no need to purchase the proprietary license. They could simply offer it to their customers under the GPL.

                    That restriction that they’re purchasing the right to apply is a limitation on the freedom of the people who obtain their software. Using the privilege afforded you under the copyright system to limit some users’ freedom is considered unethical by some, and it’s one reason the FSF and others consider it a sort of ethical taint.

                    1. 1

                      Taking that train of thought to its logical conclusion everything that services a software selling corporation is ethically unjust and should be viewed with equal disdain.

                      After all the programmers, banks, office renters, baristas servicing them coffee, and healthcare workers taking care of sick employees are working towards helping them releasing a paid-for product, thus restricting user freedom.

                      But again, I’m coming at it from a pragmatic viewpoint wherein the world still operates with money and you can have different degrees of ethical behavior even if the system is not perfect from whatever utopian viewpoint you want to look at it.

                      1. 2

                        While you won’t find me to be a strong advocate for the FSF along these lines, I do understand their point of view and I think you’ve misunderstood it.

                        Of course the world still operates with money. And of course companies can charge you for software. The user freedom restriction does not lie in the fact that companies charge for it. Take, as an example, Red Hat. They will sell you Red Hat Enterprise Linux and not even the most ardent Free Software zealot will claim that doing so infringes on your freedom. The GPL explicitly allows for selling software.

                        That is because, even though they sell it to you, offer you all of the rights to the software that the GPL does. As a consequence, Oracle, Scientific Linux, and the Community Enterprise Operating System project (CENTOS) also distribute the software for free. CENTOS is now even sponsored by Red Hat themselves.

                        “releasing a paid-for product” is demonstrably not “restricting user freedom.”

                        Preventing your users from exercising the four freedoms as outlined here is what they consider ethically tainted, not any payment that changes hands.

                        Offering software under a license that does not afford those four freedoms does restrict user freedom and that restriction is where strong Free Software advocates perceive some level of unethical behavior.

                        1. 1

                          Taking that train of thought to its logical conclusion everything that services a software selling corporation is ethically unjust and should be viewed with equal disdain.

                          After all the programmers, banks, office renters, baristas servicing them coffee, and healthcare workers taking care of sick employees are working towards helping them releasing a paid-for product, thus restricting user freedom.

                          I might be misunderstanding something, but wouldn’t usually the users of the software – the banks, office renters, etc. be the users and have the source code – they “use” it, right?

                          Baristas and healthcare workers already operate under restricted contritions, within whatever organisation employs them. They are in no position to control anything to begin with (and that’s ignoring that a lot of software is written in a way that doesn’t encourage it), making that situation more difficult to begin with.

                  2. 4

                    for who wants another reason big Corps release OSS: Commoditize the complement. The above has been linked here before https://lobste.rs/s/tfquxp/laws_tech_commoditize_your_complement

                    1. 3

                      One of my favorite examples of dual-licensing has been the idTech1-3 engines.

                      Releasing that tech for people to learn from and modify probably created entire generations of programmers.

                      1. 4

                        In the open-source communist utopia, everything is open source and nothing is for sale

                        There is nothing communist about Free Software, and I politely ask you stop using this as a slur against it.

                        1. 5

                          I’ve always thought of it as (lowercase) communist. Per Wikipedia:

                          a socioeconomic order structured upon the ideas of common ownership of the means of production and the absence of social classes, money and the state.

                          If “means of production” is source code, “social classes” is developers vs. consumers, “money” is charging for software, and “the state” is copyright law, that seems to fit pretty well.

                          Granted, this is the post-scarcity Utopian flavor of communism, nothing Leninist about it, closer to Ian M. Banks.

                          1. 1

                            Source code isn’t a “means of production”, it’s just instructions for operating some kind of machine (be it some abstract machine, concrete machine, or absolute machine). It’s not even physical. Also RMS is absolutely in favour of one charging people for use of their software, as long as users are afforded the four freedoms: it’s why the common suggestion is to “charge for support”.

                            1. 1

                              Software being nonphysical strains the definitions a bit, but then all software is a bit communist (“information wants to be free” and all.)

                              It’s the object code, not the source, that’s the instructions for the machine. Source code is the means of producing the object code. Which is more valuable: a copy of Photoshop.app, or the source code of Photoshop?

                              Charging for support is a valid business model (it pays my salary!) but it isn’t the same as charging for the software; it’s service vs. product. Gilette and Merkur have very different business models! You cannot viably charge money for use of GPL software because it’s effectively a commodity market and the cost of production is near zero.

                              Sorry if this is off topic … but it’s an interesting debate, I think.

                          2. 3

                            Change, meant as a jest at the impracticality of it rather than as a slur to associate it with the political movements, my bad.

                            1. 4

                              That’s disappointing. I think that you haven’t seriously considered the politics of Free Software, then; it is not just about what people can individually do, but about what society can require people to do. Indeed, it is well-known lore in the Free Software community that copyleft’s implementation is tightly tied to the legal structure of copyright in each jurisdiction.

                              Further, along the same lines as my other question, exactly why is communism impractical? Why is copyright reform impractical? I think that you are artificially restricting the window of discourse here.

                              1. 2

                                My attempt was not to make a definitive claim that FOSS is impractical, but rather to say “my gut impression and experience tells me it might be”, hence why I wanted it to come off as a joke rather than an assertion.

                                Anyway, re-worded that particular bit now :)

                            2. 1

                              I would be curious how to move this forward better than just “don’t do that”. Was the concern with the whole phrase, or just communist? What is an end state that open-source is shooting for? Would “collaborative” be better than “communist”? How would you rewrite the sentence such that it was guileless? Did the edits solve your problem in a way you found satisfying?

                              1. 5

                                If his opinion is that open-source (which should be Free Software, given the context) has utopian ideals, that’s fine by me, however it’s unfair and incorrect to label it “communist”, as there’s nothing communist about it. In this case it’s being used as a slur. I would’ve written “In the open-source utopia…” (or “In the Free Software utopia…”).

                                Isn’t it ironic that the proprietary software developers call us communists? We are the ones who have provided for a free market, where they allow only monopoly. … if the user chooses this proprietary software package, he then falls into this monopoly for support … the only way to escape from monopoly is to escape from proprietary software, and that is what the free software movement is all about. We want you to escape and our work is to help you escape. We hope you will escape to the free world.

                                - Richard M. Stallman

                                1. 2

                                  Thought so. I think that communist has become pejorative, so I agree that it’s frustrating when those interpretations get mixed in. There are many well meaning people who consider themselves communist, so that’s also problematic to use it pejoratively. It’s ironic that utopia was originally pejorative and has now become ‘good’. Imprecise language will more often get the straw man treatment than the steel man treatment. Then add sarcasm on top of that…

                                  I do not consider myself communist in any way, so I am approaching this from an intellectual point of view; so I was not personally offended by using the word ‘slur’ with the word ‘communist’, but ‘slur’ is a strong word and could make some people feel excluded.

                            3. 2

                              The author says BSD/MIT/Apache-type licenses are used by very large corporations on the one hand, and hobbyists and nonprofits on the other; implying other companies don’t use them. That’s not true in my experience. My employer (Couchbase) has Apache-licensed its software since it was founded. I run across plenty of software from small companies/startups that’s licensed this way.

                              I’m sure part of the reason for this is competitive — many prospective users or contributors will see a GPL license and walk away, because they don’t want to abide by those terms. The author themself admits this problem, pointing out that dual-licensing isn’t transitive, so even companies doing this GPL/commercial dual license would stay away from each other.