Gift of open source FreeBSD for Nintendo of private property?

Hello community!

Is it ethical and morals that the free software of your code modified for the commercial use of private property without receiving anything?
If you want to hang on to it (or parts of it) then you need to make that clear. It really irks me that some companies get other people's hard work for free and make big money on it - nicer companies, not so much. But that's just my personal feeling. The bottom line is that a gift is a gift. Many companies, like some people, have neither understanding nor interest in ethics and morals. Such is the world.
Yes, it's both ethical and moral since developers of FreeBSD (and other BSDs of course) use the BSD license which allows this use.

Why should be considered wrong to do something the authors are explicitly telling you is perfectly fine?
It depends on the license. GPL family or another copy-left license, absolutely not. BSD, MIT, ISC, or another permissive license, no problem. In fact I have a real problem with Richard Stallman insisting on calling GPLed software "free" when each iteration of the GPL gets longer, more complex, and more restrictive. IMO the GPL and AGPL are like a black hole. Any truly free software that falls in, never comes back out again.

So I would ask: Is it ethical for a programmer to take a part of FreeBSD, incorporate it into Linux, change the license of the incorporated code to GPL, and then say they are giving back to the community? They are giving to the Linux community, but they're doing squat for BSD. There's no back about it.
Scott Miller , I believe it becomes dual licensed when that happens.

I sort of see a problem with FreeBSD licenses. I don't know if this is a founded thought, that there can be patent trolls abusing code, but I'm not sure if it's an obvious addition, that if someone else adds to the BSD code that is similar but independently developed, the contributor organization can be sued for infringement.

The problem with GPL code is, it is often dual licensed, in a way that a company gets to keep all rights to code, and that 1 company and their business partners benefit from others' contributions. I believe this makes it so no one wants to invest in cleaning up code, or improving it much, so there becomes this archaic dependency tree for a simple program, that should take less than 10 minutes to compile, instead of 14 hours.

It seems like companies should give something back, even if it is little, or a tiny fraction of what they receive to BSD or MIT licensed programs, but that's not a big deal. The big deal would be patent trolls making it difficult for others who want to improve an operating system, if there are few ways to get something accomplished.

teo, I think Nintendo and others should give something back to the FreeBSD community, but they don't owe giving up their game console coding, or part of their mainstay.
Companies should give something back, even if no one is forcing them to. Apple has "borrowed" code from CMU, FreeBSD, OpenBSD, Konqueror, LLVM, and others. After much work and improvements Apple has republished the sources as Darwin, WebKit, and more, as well as direct support of some projects: And of course Google is a major contributor to open source, as was Sun before Oracle screwed them up. And these examples mostly feature permissive licenses. Even Microsoft has given back in the form of cash with between $35,000 to $75,000 given to the OpenBSD foundation starting in 2015. And who can forget Netflix rewriting the FreeBSD IP stack and Ethernet drivers to squeeze out maximum performance, and then submitting the source code back to FreeBSD.

As far as permissively-licensed code added to a GPLed project, the whole of the code simply becomes GPLed. Only if the code is not linked can the licenses remain separate. Anyone can change a BSD, MIT, or ISC license to anything they want; not so going the other way. Before Oracle, Sun had a weird license on their ZFS code. I haven't read the license, but I heard it was specifically crafted to prevent it from becoming GPLed, but the code could be used in any open-source project that allows mixed licensing. Now that Oracle has cast off the old open-source projects, OpenZFS is stuck with the old license, but they support the effort to port ZFS into the Linux kernel (that is, OpenZFS seems to have no intention of enforcing the license).

In theory patent trolls should not be able to feck up an open-source project. Darrel McBride tried it and failed rather spectacularly. And Rambus tried it with hardware when they joined a standards body, then used the information in filing patents in an attempt to own SD-RAM and DDR-RAM technologies. That backfired too. As far as submarine patents, recent changes to US patent law should kill those. As always it should be impossible to patent anything that's public knowledge (as Rambus tried). As much as I'm not real fond of Richard Stallman, when he's right, he's right: Software patents are evil.
Companies should not have to do anything. No one should. If you truly value free software and the freedom that goes with it then you'll apply this freedom in an absolute way. Which is exactly what the BSD license does.

It's just like freedom of speech. That should be (and is) also absolute, and does not only apply to those opinions which you may happen to like and/or favor. It should also apply to those people who's opinion you cannot stand.

Freedom of software should be the same, not this "free, but only as far as I like it" nonsense, because in the end that's not free.

Personally I put much more value to people and companies who give something back because they want to, instead of those who do so only because they have to.
A BSD/MIT/ISC license doesn't lose the code, when a GPL project uses it for their own. There are just two or more exact copies of the code, with each license. Each addition to the GPL or proprietary code of that copied from a BSD license, simply, FreeBSD cannot use. The BSD/MIT/ISC code that is shared (among GPL or proprietary) simply becomes dual or multi-licensed. As I've read, with a BSD type license, the code simply forks.

Companies should give back something, but if they don't, harm is not really done. Companies should be able to use an operating system, programs and tools, then be able to keep what they've done secret, without having to throw everything that isn't solely dependent on the OS or BSD programs back. Which GPL doesn't allow.

My concern about patent trolling or a restrictive license on an open license is: what if a BSD licensed program is made. Then a GPL (or proprietary) project uses it, then adds the most obvious addition(s), thus GPL'ing (or patent trolling) that, which was missed by BSD/MIT developers. Does BSD have to make inefficient code to go around that, which was the most efficient and obvious code? Does someone get in trouble for unknowingly and independently adding code to their BSD program, because GPL followed their work, and swooped in the next day (or any other time period), adding the most obvious code, before the originator of nearly the entirety of that program did? The idea that this can happen, annoys me.

Scott Miller, as for license, I think you'll appreciate an Apache license, or at least some ideas behind it. It has a clause against patent trolls (I'm not sure how this is exactly defined), and companies are allowed to keep their source code secret.
A BSD/MIT/ISC license doesn't lose the code, when a GPL project uses it for their own ... the code simply forks.
True. What anyone does to a fork has zero effect on the original. I'll explain what I meant.

Let's say some BSD project creates something kinda cool... for example the Hammer file system. Another BSD project also has cool stuff, but they want to give give Hammer a whirl. So somebody on the second BSD project gets the Hammer source, forks it, and ports it to this second BSD. Great! But in doing so they find and fix a bug in Hammer, or maybe they add some awesome feature. The first BSD is free to take the second BSD's mods and pull them back into the original.

This can't happen if a Linux developer ports Hammer, unless the developer is kind enough to give their changes back to BSD. Of course the moment Hammer touches the Linux kernel all of that fork falls under the GPL and that any mods made from that moment forward cannot be changed back to the BSD license. So if our Linux developer found a bug and debugged it on Linux, the change is lost to BSD. However our kind Linux developer could verbally describe how they fixed the bug. That's kosher.

Anyway no dual licensing about it. One fork is BSD licensed, the other fork is GPLed.

I'm not sure how you define patent trolls. Patents cover a method, formula, or design. While copyright covers the expression (mostly a line-by-line copy, but it might be only 20 lines and not the whole thing). Once a method, formula, or design is made public it cannot be patented, but patent examiners f* up all the time and issue patents they should not. The power of a patent is not the the text and drawings that explain it, but in the claims. The issue with open source and patents is when somebody (say Microsoft) has patented something (say a new search algorithm) and then some clever programmer discovers the same algorithm independently and puts it into an open-source project. Microsoft stumbles across the use of their algorithm and they decide to enforce their patent.
Even if they're not contributing with code or money, it could be argued that companies like Nintendo are contributing just with their name - It's great press to be able to say that the PS4 or the Switch runs on FreeBSD.
So if our Linux developer found a bug and debugged it on Linux, the change is lost to BSD.
That is a good example. I'd hate to argue against BSD licenses, but that is a detail I dislike.

Something I thought about is, that driver forks shouldn't (even if they are allowed to) be GPL'd or patented unless the company itself made that hardware, or developed much of that code. In some places GPL works, like simple user-end programs, small originally developed programs, or specialty programs, but Apache works way better in many of those cases.

It would be nice if there was a license that prevents a code from being GPL'd, until after a set time period so it can be fixed without interference, but then ensures that it becomes fully BSD licensed after that. A small problem with that could be, each line of code would be on a delay from the time it was created to be fully BSD licensed, but it doesn't have to.
I'd hate to argue against BSD licenses, but that is a detail I dislike.

Then don't. The license made the code free; someone else abused it. That's just what you live with. The alternative is creating your own "copy-left" license similar to the GPL that requires everyone to contribute back. Then nobody uses your code except the people who were planning on using your copy-left license anyway. What you end up with is the exact same mess the GPL created in the first place. As for the idea of a license that prevents code from being immediately subsumed by the GPL, I would bet that the only positive thing that would come out of it would be a lot of GPL advocates realizing just how "free" their license really is once they're subjected to the same problems. I would bet most people would just refuse to use the code.

The GPL is just an unusually permissive patent. I'm sure plenty of people could come up with some tangle of dubious logic to respond to that claim, but I can't think of a better way to describe it: "You can use my code for anything you want, as long as what you want to use it for furthers my own agenda and you agree not to use it to further any agenda I don't agree with."
The point is: anything slightly larger than ad minima, simple bugfixes or obvious to MIT code shouldn't be patented or claimed by GPL or propriety licenses to be lost.

If someone forgot a comma, someone shouldn't be allowed to rush in, and patent that code with the comma.

If there's a math problem that takes 10 pages to complete, that is so efficient, there's only one way to complete it flawlessly. That developer made 1 mistake, or left off a comma the equivalent of a few lines, but the program still runs, with bugs. Someone shouldn't rush in, fill that code that was the developer's intent, taking it away to be used by anyone, as the original developer intended. To the point where, the only way to make that program run flawlessly, is for the developer to rewrite nearly entire program.

And GPL isn't the only alternative, Apache is. I don't know if there is a good middle ground between a BSD license and an Apache license, that allows anyone to use it for anything, or improve it, without having to be forced to sacrifice original changes while not impeding the freedom of original code.

If a GPL program was made of originality, and used more permissive libraries or a compiler. That's great, that's their program, of their work and their right. Those libraries or compiler would be the equivalent of the toolset to be used for liberty to do that, and it's not lost which allows others to do so.

As for a such time delay license, that wouldn't be an MIT license, it would be a different license that after a short time, automatically dumps the code to an MIT like license, without restrictions, releasing it completely once that happens. Also, I don't think that a time delay license should be enforced by BSD, but instead just be pointed out.