nirimda
Joined 4 years ago
Joined 4 years ago
As far as I know, the FSF takes the view that linking is a logical concept not a technical one, and so communicating via IPC is just as much of a problem as loading a program into your own addressable memory.
> This conclusion is absurd: therefore, our premises are wrong.
I don't think you've demonstrated that it's absurd. For instance, it could be that MySQL does not believe it is a problem, and does not intend for it to be a problem, and will never sue for it - but that MySQL is wrong as a matter of law, and one day the FSF will sue someone in court and win and the Oracle lawyers will realise they have new opportunities for financial gain. Personally, I think that reality is more like this - the FSF and Oracle have different ideas about what it means to release code under the GPL and so the freedoms you get from the FSF are different from the freedoms you get from Oracle, and it's unclear to me what will hold up in a court of law. I certainly don't think there's anything absurd about the notion that different agents have different intents and conflicting understandings. (Note that I take the notion of freedom to include the confidence that I won't be sued by a rational agent for doing something, regardless of whether I could plausibly win the case or not.)
> I know the industry behaves as if there were a difference, but legally, is there? Show me the case law.
I don't think it makes a difference whether the case law is there. The difference is made by whether you're willing to go to court over it. If there is a chance that you will win a case, and there is a chance that you will loose a case, and that if you lose the case you will have to spend the next six months on full time development just to get back where you were before hand, then you might say "even though my lawyers say there is an 80% chance that we will win, I would rather use this BSD alternative, because the risk of that 20% are existential".
So, fundamentally, this is a case of put your money where your mouth is. If you think the GPL does something different than what "industry" thinks it does, then make your business, make your millions, and dare someone to sue you. No one else has an obligation to do that just because you haven't seen the case law.
> I don't have permission to have it on my machine except by following the rules of the LabVIEW license. I don't need permission to have libmysql.so
Btw, here you have a false premises. You don't have permission to copy libmysql.so except by the terms of the licence. I think you've made a mistake. Let's go back. You said "I can already freely copy libmysql from system to system in either source or binary form. The GPL grants me permission to do that." But now you're claiming that the GPL's grant of permission is so absolute that you don't need the permission that it grants. In fact, the terms of the licence are limited, and the question is only to what extent they are limited.
In any case, there is one important consideration. And that is the intent of the FSF. If the terms of the GPL fail to have the legal consequence they intend, and they can modify the GPL to have the legal consequence they intended, then you can be sure they will. And if Oracle has a different intent, and likes the legal consequences that the GPL has, then they might continue to use the unchanged licence. But arguing about whether the GPL does to the FSF's code what the FSF wants the GPL to do is more about arguing about whether it is buggy, then arguing about the feature set. You are well advised to listen to the FSF's interpretation if you want to rely, indefinitely into the future, on an up-to-date version of the FSF's code. But the FSF's interpretation might not really be as important when it comes to Linux or MySQL or any of the other GPLed code bases out there.
In the early days of the internet, few enough companies wanted to advertise on the internet - advertisers viewed it already as targeted at a certain segment of society - so advertisements were generally very low value i.e. crap. Tracking technology let advertisers know that they could actually find the people didn't realise were using the internet. But nowadays we all know everyone is on the internet, and we tend to use the same sites regularly, so you could get adequately targeted ads (as a set of eyeballs - not necessarily as an advertiser) just by using the internet.
It's clear that the abolition of the death penalty isn't actually all that relevant to this scenario. We can still judge whether or not shrx was the sovereign of his territory or not.
For instance, going back to the "about the size of Singapore" example, OP might try to find a nice perch next to some critical strait, and sink any vessel that passes through which is registered in a country that doesn't recognise them. But if OP gets too good at this, then the US Navy will be upset and start shooting their weaponry at OP. If OP manages to sink a few of USN's vessels, it's possible USN will say "well we will stop shooting you if you let through our vessels", but I wouldn't hold my breath.
It's probably just cheaper and easier to marry into a royal family from some small country that whose royals still have a political power, like Brunei or Liechtenstein, then secretly start a secret murdering spree until your newborn is the only royal left and they offer to make you regent, then launch a self-coup against your own six month old.
On the other hand, I gave up some kinds of requests. For instance, I used to try "start directions home" when I was driving and it would say "here's a route I found, do you want to start (or some such)" and there would be no way to actually start the directions home without breaking the very expensive law against touching your phone while driving. Does that work today? I don't know, because I've mostly been driving with Android Auto in the last few years and my wife's been in the car on the rare occasion I haven't. But it seems like the Assistant team could straightforwardly improve it.
Nowadays, I think menu options in user interfaces are much rarer, and complex stateful applications are usually HTML web programs where the disabled flag is a hint to the web browser to reject the interaction. Some of these web programs color submit buttons in a washed-out version of the normal color until the form is fully validated, but they will report the reason (to a greater or lesser utility) when clicked - such a widget is not formally disabled to the computer engineer, it's just presented to look like one. I find this subtle distinction frustrating, because it represents an ambiguity of thought that makes precise conversation difficult. Why should a widget ever reject interaction? A widgetset/toolkit is just a medium for dialog between a user and the developer, and they should always be allowed to communicate. A software developer should be able to say "hi widget set, please let the user know this button doesn't make sense at the moment" but they should not be allowed to say "hi widget set, if the user wants to tell me something - i don't want to know it, just throw it away. we're not on speaking terms" (They could, of course, completely ignore the user, but it's intuitively obvious that they shouldn't completely ignore the user. Most developers intuitively want to communicate the reason for the error if they know it's possible for a button to be clicked when they can't handle it, but they often get frustrated because the UI designer didn't clearly indicate to them how they should communicate errors - but perhaps they them what they shouldn't do and now they are stuck).
I liked the option 5 mockup in the link, although I'm not so sure it works for actions (like shooting) so much as state toggles (like activating the weapon). I do strongly disagree with the reasoning at the end of the page "it's okay to break the rules for a piece of software that people often use", because it's 100% a case of "rules for thee but not for me". Aside from the fact that I might have been using Outlook until I changed jobs to a new one (and there's a lot of people who only use Gmail unwillingly/primitively and attempt to use the phone and Teams and Slack and meatspace for their communication needs), it's exactly the most commonly used programs that set the norms for users and software developers. We know how to communicate because we imitate previous dialogues. If the most commonly used programs get to break the rules because some of the people who use them use them dozens of times a day whereas others only want to use the features once a week or two and only manage to use them once a month or so, then the members of both parties will come to the view that cryptic software is fine - one because they use it all the time and have no problem, and the other because they see that hard-to-understand software is highly regarded. And so the designer of a widget designing tool will say "no, it's fine for the widget to show only when it's available, because the people who use this widget-designing software will almost always be using it daily, and they'll only have to learn it once at the beginning of their career". Are they correct? Who knows. At this point it's just a position in the design space by the user interface designer.
Afaik the FSF agrees with your dichotomy and expresses the latter opinion. Take for instance their faq "You cannot incorporate GPL-covered software in a proprietary system. ... However, in many cases you can distribute the GPL-covered software alongside your proprietary system. To do this validly, you must make sure that the free and nonfree programs communicate at arms length, that they are not combined in a way that would make them effectively a single program. The difference between this and “incorporating” the GPL-covered software is partly a matter of substance and partly form. The substantive part is this: if the two programs are combined so that they become effectively two parts of one program, then you can't treat them as two separate programs. So the GPL has to cover the whole thing."
In another question, they address the notion of what might be considered a single combined porogram. "It depends on how the main program invokes its plug-ins. If the main program uses fork and exec to invoke plug-ins, and they establish intimate communication by sharing complex data structures, or shipping complex data structures back and forth, that can make them one single combined program. A main program that uses simple fork and exec to invoke plug-ins and does not establish intimate communication between them results in the plug-ins being a separate program.
"If the main program dynamically links plug-ins, and they make function calls to each other and share data structures, we believe they form a single combined program, which must be treated as an extension of both the main program and the plug-ins. If the main program dynamically links plug-ins, but the communication between them is limited to invoking the ‘main’ function of the plug-in with some options and waiting for it to return, that is a borderline case.
"Using shared memory to communicate with complex data structures is pretty much equivalent to dynamic linking."
So I don't think that the FSF intends that you can use a technical means to escape linking. You cannot take a GPL library and write a pair of libraries which expose its functions via a socket because the result would almost certainly involve "function calls to each other and share[d] data structures".
https://www.gnu.org/licenses/gpl-faq.html
As to whether this puts into jeopardy anyone in particular who uses Linux or libmysql in proprietary systems without additional licences, well, that is a different matter. The FSF's interpretation of the GPL tells you something about when the FSF might sue you and about what revisions might be made to the GPL in the future. But it doesn't tell you about when the copyright holders of Linux or libmysql might sue you, or what they will do if there's a GPL v5.2 released tomorrow.