Trying to understand an old custom license

Question

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 ?

Answer 1

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).

Answer 2

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.

Answer 3

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.

Answer 4

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.)