12

I found this code that I want to use: https://github.com/ObjectivitySRC/PVGPlugins/blob/master/NonBSDPlugins/DataMineReader/dmfile.h

The license is on top and states:

   If you do use this code please do two things:
   1) Acknowledge my contribution
   2) Send any changes, enhancements, etc for me to add

I have a few questions:

  1. Is the "please" terms make each requirement non mandatory, hence making this similar to a Zero-clause BSD ?
  2. I do not know how is "me" in the context, but one woudl reasonnably assume that this the main contributor listed below: "Jeremy Maccelari", which I can acknowledge. However, the listed email adress do not work. How am I supposed to send this person any changes ? What am I expected to do here for ?
  3. Is there an example of a classic open source or FSF license asking the modifications to the code are sent to someone specifically instead of being put simply open source or distributed under the same license ?
3

4 Answers 4

19

For (1), the only answer is "nobody knows" (apart from possibly the person who wrote the license). Given that, I would therefore be conservative and assume that it is a mandatory requirement.

(2) and (3) are a very good indication of why an open source license (as defined by the OSI) cannot include such a requirement; the normal example here is the desert island test, but (2) indicates the reverse problem: if the maintainer ever drops out of contact, then it is impossible to fulfil the requirement and the code becomes unusable (or at least, undistributable).

5
  • 4
    Actually, the answer to (1) is "No, because the 'license' does not state what permissions you get other than 'use'. That is a very reduced set of permissions compared to BSD-0." And that is apart from your remark about knowing the intentions of the author. Jan 10 at 16:13
  • 2
    @BartvanIngenSchenau I think from the context in the license language you can assume that the word 'use' is to be interpreted in a broad way, otherwise the the language in lines 1) and 2) would not make any sense. But I agree, more clarity would be better. Jan 10 at 16:33
  • Well, have you not by sending the email sent the changes to him, but it was him failing to receive it that caused the issue? Have you not sent the changes then?
    – Hobbamok
    Jan 11 at 9:26
  • 1
    In this kind of situation I ask myself "is anyone likely to object"? I've learnt that if you're distributing code onwards, then people downstream are very likely to object, because they employ expensive lawyers who have to earn their keep; but it's very unlikely that anyone upstream (like the author of the code) is going to object, because they've clearly indicated that they've published it in the expectation that people will want to use it. (And they've also indicated that they don't employ lawyers...) Jan 11 at 14:42
  • 1
    It's even worse than "nobody knows". It's up to a judge's interpretation, which will vary from one locale to another. Re-using this code is definitely a legal minefield.
    – bta
    Jan 11 at 22:07
24

This is not a license, as it grants no rights.

By default all works are copyrighted and their allowed use is limited unless the rights owner gives you further permissions. Licenses grant further permissions and contain language such as "Permission is hereby granted -- subject to the following conditions --" or "Redistribution and use -- are permitted provided that --".

This file does not grant such permissions, so you can only use it within fair use limits of your jurisdiction. If you do use it, the author has some requests. In that case the requests are entirely voluntary, if you already have the fair use rights by the law.

2
  • 1
    While the other answer answer my specific questions, this answer is also an important one. Jan 11 at 22:46
  • 1
    @MathieuWestphal: This does at least answer (1) - the license is not only not equivalent to a Zero-clause BSD, it is the exact opposite, being legally equivalent to "all rights reserved."
    – Kevin
    Jan 13 at 1:13
12

In a corporate environment I would advise my colleagues not to use this code for the reason that it is an unconventional license and the legal interpretation is not clear. This would even be in case it is a transitive dependency. You might want to keep this in mind if you plan to use this code in software which would be used by corporations. (This is on top of Philip Kendall's answer, with which I fully agree)

On the practical side, however, if you list the original author in the attribution notices of your software, possibly adding the GitHub-link, there is nothing in these license terms that would lead corporations into a 'fatal situation' (e.g. being forced to publish proprietary code due to copyleft terms). The failure (due to inability) to notify the original author about changes, enhancements could easily be cured, if that was ever brought to court by the original author. If you were concerned about this you could try to do this communication of changes by creating a pull request in GitHub.

6
  • I overall like and agree with this answer but as a company I'd be a little leery of the ambiguous scope of the copyleft-ish requirement in #2 (i.e., in various situations, to what degree does adjacent code constitute a change or enhancement?). But then, I'd already be going in with a blanket skepticism about a crayon license, so perhaps that specific concern doesn't matter so much.
    – apsillers
    Jan 10 at 15:27
  • 7
    As a company I would not just be 'a little leery' about this. As mentioned above I would veto its use, and this would be a roadblock for the product release. The second paragraph of my answer is intended for those who do not have that strict policies and procedures in place. Jan 10 at 16:42
  • Even with GPL code, there is nothing that could "force to publish proprietary code". You would however be required to stop distributing the code and possibly pay damages. That is why many companies find it more desirable to comply with the license. With unlicensed code such as this, you don't have that option.
    – jpa
    Jan 11 at 7:23
  • @jpa I would not take this lightly. GPL is enforceable in many countries and source code had to be disclosed. Some examples can be found at the following links: wiki.fsfe.org/Migrated/GPL%20Enforcement%20Cases , sfconservancy.org/copyleft-compliance , gpl-violations.org , just to name a few. Jan 11 at 9:09
  • 1
    @Martin_in_AUT Even there the companies that did release source code did so voluntarily to avoid other punishments. E.g. Westinghouse did not or could not, and got: "Westinghouse’s infringement to be willful and therefore awarded treble statutory damages of $90,000. The court also entered a permanent injunction prohibiting distribution of HDTV products with the BusyBox software and further ordered all infringing HDTVs to be forfeited to the plaintiff". If you have any case where court has actually forced publishing of proprietary code, I would be interested.
    – jpa
    Jan 11 at 11:26
9

As jpa notes, there is no license here. The notice you've quoted grants no right to redistribute the code, with or without modification. (And yes, I checked the full comment at the top of the original file; there's no license grant there either.)

One could possibly try to read an implied license to "use" the code, in some manner such that "acknowledging" its original author and making "changes" or "enhancements" to it is meaningful, into the notice you've quoted, on the basis that without such a license the requirements listed are meaningless. But that's a rather shaky claim, not only because such use would not necessarily need to involve redistribution of the code — e.g. internal use in a company or private use for academic research purposes could easily qualify — but also because there's a priori no reason to presume that the notice isn't just a restriction on or a restatement of some actual (free or non-free) license the author may have granted, or intended to possibly grant, elsewhere.


Still, it does seem plausible that the author did in fact intend to grant such an implicit license, or at least did not intend to exercise their right to restrict use and redistribution of the code or derivative works of it. (It would've been so much nicer if they'd just bothered to include some actual words saying so, like "you are free to use and redistribute this code, with or without modifications, for any purpose.") If so, it's unlikely (but not, of course, impossible) that they'd suddenly turn around and sue you for distributing it, even if you have no proper license for doing so.

At that point, the question becomes what you consider to be the easiest and safest option. Personally, I would probably proceed in something like the following order:

  1. The best option, if feasible, would be to contact the original author (and any later contributors) and get them to release the code under an OSI-approved license such as two-clause BSD. (The maintainers of the project you linked to would probably appreciate that too, since that's their default license.)

    Admittedly that's a bit trickier to do if you don't have a working e-mail address for them, but you can always try to track down some more up-to-date contact info for them. In fact, in your case just Googling the author's name turns up active Twitter, Facebook and LinkedIn profiles that all seem to belong to the same person — a software developer currently living in London, UK. A bit more searching makes me about 99% confident that this is indeed the same person who originally wrote your code, even if they've changed jobs and moved to a different country in the mean time.

    (Of course, this tends to be easier if the person you want to track down has a distinctive name, like here. If the author happened to be named John Smith, this would be a lot more difficult.)

  2. If you can't track down the author(s), or if they refuse to grant you a suitable license, the second option to consider would be reimplementing the code yourself.

    If you want to be sure not to accidentally leave any old copyrighted code in, you could do a clean room reimplementation: document what the code should do and write a comprehensive test suite for it, and then hand the documentation and tests over to someone else who hasn't seen the original code and ask them to reimplement it from scratch. This can take some time and money, but the up side is that not only will the resulting code be 100% novel and free of unclear license issues, but it will also have comprehensive documentation and tests. :)

    That said, a full clean room rewrite may be overkill unless you know the original author to be highly litigious. Typically, an experienced programmer should be able to analyze the behavior of a program (or a component of one) and reimplement its functionality in their own preferred programming style without duplicating any distinctive and copyrightable aspects of it. (Of course, either way, the old and new implementations will still e.g. implement the same API, which will likely lead to some similarity. But such minimal copying for the sake of interoperability is typically considered permissible under fair use or equivalent legal doctrines in other jurisdictions.)

  3. If neither of the previous options seems feasible (and you still need the feature the code provides), the last option would be to just use the code as it is, and accept the risk that comes from the license ambiguity.

    Ideally, you should try to encapsulate such dubiously licensed code into a separate module, away from the rest of your code, so that if the original author ever shows up and complains about you using it (or if someone refuses to accept your code because of the unclear licensing), you can just yank the problematic code out with minimal damage to the rest of your codebase. (Of course, if the code was providing an essential feature, you'll then be forced to reimplement it anyway, but at least you won't have to rewrite the rest of your software.)

2
  • As far as #2 goes, the file in question only contains a couple of class definitions (no implementation) related to a specific file format. If OP can find the spec for that file format, re-implementing this code should be relatively straightforward.
    – bta
    Jan 11 at 22:03
  • @bta, true, but apparently the "license" in that header applies to all the code for that plugin. I haven't looked at it all, but it seems like it may not be quite as trivial to reimplement as just one header file would be. Jan 11 at 23:12

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.