If you have to go to court on anything less than clear-cut (on either side), you’ve already lost unless you’re a law firm (or an in-house law firm for a billion dollar company).
The first step in copyright enforcement is a scary cease-and-desist letter. And that’s where the prevailing popular view does matter.
We seem to be in agreement?
Yes, exactly - that’s why I specified that you’d implement the same “solved problem” in an imperative language, rather than a declarative one like Prolog 
Without additional features of that imperative language, you can’t just “1:1 translate” the source code, you’re forced to modify it in the initial “translation” too. A big part of “running a prolog program” is how the runtime interprets & works with the declarative statements, and that’s just not built into most imperative languages.
Yes, that’s why I wrote:
So we also seem to be in agreement here? Not sure why, but your reply reads a bit like you’re trying to rebuke something I wrote; maybe I’m misreading you though.
If you may, could you expand on that? I’m not sure why share-alike licenses cause an immediate “not looking at that” reaction. Does the same also apply to CC-BY-SA licenses, and not just GPL?
I’m not sure I follow. The first thing to do when receiving a cease-and-desist is consulting with your own lawyer whether they have any basis for their claim. Getting swayed by online opinions really shouldn’t come into play here. It’s not like you just want to give in to copyleft trolls, right?
It seems to me everyone on this thread is more or less in agreement, and the nuances are legally murky territory that you can go in endless circles debating. So, maybe let’s not (unless you’re having fun debating it) 
There’s just two perspectives: one that’s excited to dive into all the shades of gray, potentially hiring lawyers and going to court and defending what’s right. And there’s the cowards like me that want nothing to do with that.
My response to the copyleft troll isn’t to “give in” — rather it’s a cautionary tale to be sure you understand licensing restrictions of everything you use. Same with “looking at” restrictively licensed and proprietary code that does something I might want to independently implement and distribute more permissively some day. I’d just rather operate in an abundance of caution and be certain I’m in the clear than step foot in murky waters.
lawyers are expensive
have you ever taken anything to court?
it’s an enormous pain in the rear, and things rarely go as you might expect they “should” based solely on reading the law
even if your opponents have no basis whatsoever to their claim, they still have the ability to waste enormous amounts of your time money and attention. oftentimes it’s just easier to settle
Getting swayed by online opinions really shouldn’t come into play here
shouldn’t but DOES
having been both
the latter will make you much happier!
In my view, you’re much more likely to be in hot waters when you look at proprietary code than looking at EUPL-licensed code. There is ample precedent (written by an actual lawyer, who was part of drafting the license) about why the EUPL is not viral (virality doesn’t really exist anymore in the EU). Of course, this is just my european POV, and this doesn’t extend to all licenses in american jurisdictions. Luckily for you, the EUPL defaults to belgian law if you’re outside the EU, so the default fallback is the European Court of Justice
If you want to stay extra cautious that’s fine, but IMO it’s better to learn about the various specifics and make an educated decision based on that
There are restrictions beyond linking virality. I cannot copy your work in Supposition.jl to implement and distribute hypothesis-based testing with an MIT license for the Julia standard library without your separate permission. As you’ve currently licensed that code to me, I could only re-distribute it under the terms of the EUPL or a compatible license. In fact, you could sue the Julia project if we tried to re-distribute your code under the terms of the MIT license. Even better, you probably could sue anyone that distributed their own Julia executable (built with package compiler and thus containing your code) if they didn’t distribute it noting that it includes code copyrighted by you that’s distributed under the terms of the EUPL. So, yeah, if there’s any chance I would implement that, I’d prefer to avoid giving myself an opportunity to plagiarize in the first place.
This goes far beyond your bog-standard “lawyers are expensive.” You need to find a good IP lawyer who has a solid understanding of open source licensing. You’re looking at a niche of a niche in an already-expensive profession.
There’s no need to do that though - since linking in EU law is not viral, there’s no problem to have an EUPL standard library in an otherwise MIT project.
Of course, that’s completely unrelated to the fact that I’m open to giving a special license to the Julia Project or an otherwise representative entity At that point though, you might as well just use Supposition.jl without copying anything, since I plan to continue maintaining it for a long time to come In addition, just testing a library or software product with Supposition.jl has no impact on the licensing situation of that library or software product, so even without it being a standard library, nothing stands in the way of testing Base or a standard library with it.
I didn’t mean to give that impression, certainly not a rebuke. My aim was to explicate the law as I understand it. I do think we have different perspectives on the relevant law, but I don’t see substantive disagreements here. To caricature those perspectives, you’re more focused on what someone might plausibly get away with, while I’m more focused on what will definitely not get you sued, or if someone really has it out for you, at least an early dismissal with prejudice of the case. I have a severe allergy to the courtroom.
Sure. I strongly favor permissive licensing, although I have written both proprietary and copyleft/GPL code. When I’m working on software I intend to release under MIT or BSD, I’ll often look through source repositories (realistically this means GitHub) and check out how other’s have tackled similar problems.
But only if the code comes with a permissive license. If it doesn’t, I won’t even open the page. The README and other documentation, yes that’s fine, but the code? No.
Reading someone else’s code and then writing something vaguely related to it isn’t a translation, and doesn’t incur obligation to include their copyright. Of course if I borrow code wholesale, or judge that some part of what I’m writing is imitative to the point where I owe them a shoutout, I include a comment in the code linking to the license for the original and thanking them.
Avoiding GPL code is less about the risk, which is minor, and more about the spirit of the license. People choose GPL because they want their code to be infectious, or they wouldn’t use copyleft. Since I won’t be doing that, I don’t read their work. I prefer to play with kindred spirits.
I’m happy enough to use GPL application code, and have no philosophical objections to providing a patch, although it happens I’ve only written GPL when paid to do so. I certainly don’t object to them making their own choice as to license, in fact I intend to abide by it, in spirit as in letter. One of the things that means is that I won’t even look at GPL code unless I have to. Even if I’m not writing something plausibly similar right at that moment, you never know, I might later. It’s the principle of the thing.
That’s very interesting, I share that view! I dislike the infectious nature of GPL licenses too. It’s an unfortunate truth that share-alike licenses are often viewed as infectious, when that’s a subtle difference; CC-BY-SA is not infectious, and neither is the EUPL. The crucial difference (to my eyes) between these and GPL-like licenses is precisely this freedom to link EUPL licensed code with other code, without impacting the licensing decisions of the combined work (provided you’re not modifying the library wholesale, in which case those modifications [and only those modifications] to the original library need to be licensed EUPL again; there is some subtlety regarding creating a SaaS out of a library, but that’s not really relevant here).
If I had the view that the EUPL were viral in the same sense that GPL licenses are thought to be, I’d choose MIT/BSD too, albeit begrudgingly, because those licenses don’t require downstream modifications to be shared with the community too. The EUPL is a good compromise for that in my POV, and the best choice for sharing code openly with others and keeping that code open too (note that the underlying ideas behind a computer program are not copyrightable under EU law! See directive 2009/24/EC; for the purposes of interoperability, you’re even allowed to decompile artifacts).
There’s a bunch more of really cool things about the way copyright in EU law works, and the directive (see Directive 2009/24/EC, recitals 10 & 15, which replaced Directive 1991/250/EEC with more updated language but being otherwise functionally equivalent) is well worth a read. It’s not too long, just 5 A4 pages, and the language is very straight forward
This approximates the terms and conditions of the LGPL, but still amounts to code I won’t read. I’m entirely willing to link such a package to my own code, EUPL makes it quite clear that this incurs no further obligation, but the helpfully-named “Copyleft clause” makes it clear that derived works must be licensed copyleft, in context that’s the infection I was referring to. Less viral is better than more viral, for my purposes, making the ideal licenses which aren’t viral at all, which I use when I have a choice in the matter.
I’m afraid going into detail about the different philosophical commitments which lead me into the permissive camp would take this discussion off-topic; we’ve been skirting the edge but, in my judgement, still on the side of hewing to the topic as-written.