Hacker News Reader

Comment by atgreen | Hacker News Reader

As I understand it, Microsoft has copied the Linux kernel system call interfaces and provided their own underlying implementation.

Given that Microsoft supported Oracle's view that the structure, sequence, and organization of the Java programming interfaces were covered by copyright law, then surely they would also agree that the same holds true for the Linux kernel system call interfaces.

I don't like the APIs-are-copyrightable decision, but given that's the current state, why aren't we talking about how this is a violation of the Linux kernel copyright license -- the GPL?

View on HN

One could argue that the Linux syscall interface is closer to an ABI than an API, since you don't directly code against it. Don't know what implications that has in this context, though.

One legal thing that I'm also wondering about is the "Linux" trademark. I thought the Linux Foundation kept close tabs on how you were allowed to use the trademark, and one requirement was that the Linux kernel was actually involved?

I'd say that this part of the ABI is definitely something people code directly against - so there's really no distinction between API and ABI. The parts of the ABI you don't are things like the function calling conventions, type widths, etc.

> One legal thing that I'm also wondering about is the "Linux" trademark.

This probably explains why they never talk about Linux (at least I never saw it), but always about Ubuntu. I guess they have an agreement with Canonical.

They mention "Linux" all the time. The feature is called Windows Subsystem for Linux (Beta).

It is perfectly legal to mention someone else's trademark. Else we would have text in books like "He walked over to the bar and ordered a popular sugared caffeinated beverage made by a company headquartered in Atlanta". You just can't say something that might confuse the reader into thinking that you own the trademark.

But doesn't calling it "Windows Subsystem for Linux" imply that actual Linux is involved, or even included? Suppose I marketed a range of flavoured additives to put in you Coke and called it "Simon's Flavours for Coca Cola"?

IANAL, but that would be perfectly fine ... you are totally allowed to write a piece of software, and say that it's for Windows, or for Mac. Or manufacture a piece of hardware that's for iOS, or Android. Or an aftermarket car part "for Honda", etc.

But Wine isn't 'for Windows' and this Microsoft thing isn't 'for Linux'. It doesn't involve the thing trademarked as Linux itself at all, in fact it replaces it. It's as though I wrote my own OS kernel with a Linux emulation layer to replace the Linux kernel and called it "Simon's Linux" or "Simon's OS for Linux". Suppose Wine renamed themselves "Linux Emulation for Windows".

The "for Linux" part is their hedge, I think. I recall Microsoft forced a project known as "Ultimate Windows Boot CD" to change its name to "Ultimate Boot CD for Windows".

Maybe it should be called "Windows Subsystem for Linux Applications (Beta)"

Do you really think a multi billion dollar company like Microsoft wouldn't have their legal team all over this? Do you not think they would have researched this out. Discussed their implementation, and made sure everything they were doing was going to meet the GPL copyright standards?

Sure, but that doesn't answer my question of 'why'.

Because it's a faulty premise? There is no license violation, that's why a license violation isn't being discussed (your question).

This same "multi billion dollar" company had an AI bot tweeting Nazi propaganda a week ago. They spectacularly failed in their xbox one release, having to completely retool and regroup. Their Windows Phone efforts remain a complete disaster and are now doomed to failure.

The whole "they're a big company...don't you think they've thought of this!" argument (and its many "do you really think they'll lose?" variations) is always a fallacy. That doesn't make the argument about the copyright of ABIs valid, but at the same time the notion that Microsoft is big therefore they must be right is absurd.

Well if we really believe the bot was AI, then it wasn't Microsoft's bot. It was was it's own "artificial intelligence".

But the rest of those have nothing to do with their legal team. They wouldn't implement a copy of another OS into this OS without making sure it was legal to do so.

I think the AI comment was more to the fact that, they didn't safeguard against seemingly obvious outcomes - such as internet trolls trying to get the bot to say bad things. Many companies put no-go words during username creation, hitler, racist words, etc - so why didn't Microsoft?

It might not have been simple to do, but still - hard not to see the outcome.

lol what the hell are you talking about. this thing is SUPPOSED to learn. you can't have ai and restrict what it learns, it defeats the entire purpose. isn't this the same thing that happens to people too? they go around the internet and soak up knowledge, sometimes racist, harmful, misinformation, but they soak it up nonetheless.

Well, to be clear, i didn't say restrict what it learns - i said safeguard against outcomes. Or, are you arguing that Microsoft knew the bot would slur racist insults in a laughably short timeframe, and only planned to run the bot for said timeframe?

The very fact that they had to pull the plug seems to suggest that it was not desired, and as such, it should have been safe guarded against.

An example safeguard being, limit what it can say. If it has racist/etc stuff in it, literally don't send to twitter. The bot still learns, the algos don't change, and Microsoft still gets to see what the given AI will behave like in full public. And above all else, the bot isn't a Microsoft branded Hail Hitler AI.

It sounds like you believe what happened is perfectly within reason - if that's the case, why do you believe they pulled the plug?

Did they even have any sort of filter? If they at least blacklisted these words [0], then that seems like a reasonable enough effort on its own. However, these developers would have had to be living in a bubble to not know about trolls from 4chan.

All in all, this is a lesson that some high-profile person/group eventually had to learn on our behalf. Now, when an unknowing manager asks why your chat bot needs to avoid certain offensive phrases because, "our clientele aren't a bunch of racists", you can just point him to this story. The actual racists are tame by comparison to what trolls will do to your software.

[0] = https://github.com/shutterstock/List-of-Dirty-Naughty-Obscen...

Now to be fair, we restrict what humans learn all the time. We try to teach morals and ethics to our children. We generally don't let kiddos run wild and learn whatever is around without some sort of structure.

Aside from the obvious outcome that it would be manipulated (which anyone could predict, and if well thought out it would have had "learning guards"), it didn't require some deep artificial learning -- you could tell the thing to repeat various offensive statements. It was just a giant miscalculation.

However the legal department of every company on the planet makes a risk:benefit analysis, especially in fuzzy areas like copyright law (which we've seen with the Java case....an API isn't copyrightable, then it is, then it isn't, then it is). The assumption that if Microsoft did it therefore it must be without risk is folly.

You would think that Google wouldn't implement a copy of the Java APIs in their operating system without making sure it was legal to do so, but apparently not.

Ozweiller is quite right. Big companies copy other people's stuff, breach trademarks (Metro?) and generally mess up all the time.

I doubt the ABI emulation is actually a problem, but calling it "Windows Subsystem for Linux" might well be a trademark violation as it doesn't involve Linux itself. Imaging if Wine called itself "Linux Subsystem for Windows". I think Microsoft would be deploying their legal team right quick.

You make it sound as if the "law" is easy. Everyone can have their own interpretation of the law, and often those interpretations are complete opposite. That's why we have two sides in a court of law.

Microsoft's lawyers likely decided that the move is "worth the risk". But they wouldn't be able to be 100% sure that it's either legal or illegal anyway. You can only be 100% sure after someone challenges you in Court, and then judges decide a certain way.

Lawyers never decide that something is "worth the risk"; that's not their job. In this context, the job of the lawyer is to assess the legal risk, and it's a business executive's job to decide whether a risk is worthwhile.

Microsoft as a company culture is like the opposite from the "move fast and break things" (as it probably should when you're a platform company)

but legally speaking, they seem to have adopted that culture.

"As I understand it, Microsoft has copied the Linux kernel system call interfaces and provided their own underlying implementation."

Not sure your understanding is correct, but in any case is that not precisely what Wine does on Linux when running Windows apps? Are you worried about Windows copyright violations with Wine? From Wine webpage, "Wine translates Windows API calls into POSIX calls on-the-fly. . ." [1]

[1] https://www.winehq.org/

Windows doesn't provide consistency between versions at the interrupt level, and Wine doesn't provide any interface at that level. It's basically a COFF loader, and a bunch of regular userspace functions in DLLs that do everything.

Linux, on the other hand, provides exactly that, and this wrapper makes it so that you can actually run "movl $1, %eax; movl $0, %ebx; int $0x80" and it will actually call the equivalent of exit(0).

Yes Windows does provide such a thing: http://j00ru.vexillium.org/ntapi/

Would be very interesting to see a Wine based on this concept instead...

Of course it does at some point, but they're not meant to be used by the public, which is why:

* you're linking to a URL with leetspeak in it, and not MSDN.

* the codes change so frequently.

* some of them disappear or are renumbered, even in service packs.

If we wanted to do this for Wine, then it would also require emulation or something like OS X's Hypervisor.framework to catch system calls, which seems heavyhanded when we have working code already.

> If we wanted to do this for Wine, then it would also require emulation or something like OS X's Hypervisor.framework to catch system calls, which seems heavyhanded when we have working code already.

It could also be done as a kernel level loadable module in the sort of style this Linux subsystem is being done, which is more what I was thinking. Changing a few numbers for every Windows service pack (really, not even necessary if you only support certain versions of ntdll for example) might not be so bad compare to re-implementing bug level compatibility with every Windows API.

Calling Wine "working" in its current state is a bit of an overstatement.

All I know for sure is that the whole situation was a mess. See http://fortune.com/2015/06/29/supreme-court-oracle-api/

What's interesting to me right now is whether or not Microsoft is saying it's OK in one context (linux interfaces on windows), and not the other (java interfaces on android), and why are they different?

MS doesn't seem to think that long-standing programming practices have suddenly been outlawed, as it is continuing to implement Apple's proprietary iOS frameworks in Project Islandwood (https://github.com/Microsoft/WinObjC). The ruling on API copyrightability does not set precedent in any of the courts that normally hear copyright cases.

libc is LGPL. The "problem" you're highlighting here is EXACTLY opposite what the entire open source movement was designed to prevent. It couldn't be less of an issue.

I'm not talking about libc. I'm talking about the kernel system call interfaces. They are defined by the kernel, not libc.

IANAL but the kernel _code_ is GPL. Nothing forbids you to implement from scratch some functionality with a different license. As long as you don't copy and paste GPL code.

A system call is a function entry point. The code executed when those functions are called is GPL licensed, and Microsoft wrote that from scratch.

What I'm pointing out is the absurdity of the current state of law. It doesn't matter if Microsoft wrote all of the code from scratch, because according to them the definitions of the interfaces alone -- not code and not header files -- fall under copyright law.

Oracle's position is that their interfaces were Copyright (C) Oracle and to use them you had to abide by the license from Oracle.

The whole point of open source licenses is to make it explicitly clear what you're allowed to do with the (yes, still copyrighted) material. They too provide strict terms and require you to honor the license.

So what defines a derived work? If you implement from scratch, but in order to implement must look at the existing implementation in order to get it correct, then it's possible (probable?) that the new implementation is directly derived from the original implementation.

It's not like Linux has a published license free spec. Unless they reverse engineered the system calls (possible but omg I think that would have been hard), then I'd be willing to bet that this could be easily considered derived work from the GPL.

Well, that haven't been getting it correct, so they've got that going for them :)

https://github.com/kernelslacker/trinity/pull/9

Those are effectively "header-only" and clearly documented as GPL. This is the basis of the entire movement!

This new Microsoft is open sourcing everything, maybe this own underlying implementation is on the way to be opened (maybe it's open somewhere already).

The new Microsoft is the same one that has been continuously and recently involved in copyright litigation. That didn't just go away overnight because they started a PR campaign.

This implementation is definitively a work derived from the NT kernel. If reimplementing and API propagates copyright, the only allowed licensing situation would be that MS releases the complete NT kernel under the GNU GPLv2 license.

This is not going to happen. And this is not a too bad news, because this might give us leverage (by estoppel) if MS ever wants to litigate against free software on the theory that reimplementing API propagates copyright.

But didn't they support Oracle's suit against Google's free software Dalvik on this very basis?

is it a derived work of the NT kernel if it's contained in a separate loadable driver? my understanding is that's where this system call interface is contained, and as I understand it, you can have GPL NT drivers..?

It is not very probable that only public interfaces are used to implement this subsystem. Therefore, we can think that the special exception of the GPL that exclude major components of the OS would not apply. It also explicitly won't apply in the first place because MS is absolutely in the case: "that component itself (1) accompanies the executable (2)"

(1) core NT kernel (2) Linux subsystem

I'm pretty sure you can use only public interfaces to implement this subsystem. You can do quite a lot to NT via the public interfaces, and it helps that the stuff in the linux subsystem basically only needs to work with itself (i.e. you don't need to send signals to Windows processes... but even if you needed to, you could use public interfaces to do that from the kernel...)

If reimplementing and API propagates copyright, the only allowed licensing situation would be that MS releases the complete NT kernel under the GNU GPLv2 license.

The GPL is not that expansive, it only extends to programs built upon GPL-licensed stuff, not for programs that just happen to have a GPL application running on them.

  A compilation of a covered work with other separate and independent works,
  which are not by their nature extensions of the covered work, and which
  are not combined with it such as to form a larger program, in or on a
  volume of a storage or distribution medium, is called an “aggregate”
  if the compilation and its resulting copyright are not used to limit
  the access or legal rights of the compilation's users beyond what the
  individual works permit. Inclusion of a covered work in an aggregate
  does not cause this License to apply to the other parts of the aggregate.

I'm not talking about that. I'm talking about the hypothetical situation where an API itself is considered inheriting copyrights from the reference implementation -- similar to what Oracle argued about Java and Android.

Even if it was, the NT kernel wouldn't be affected, that's my point; only the translation layer would be.

It would be pretty weird if, for example, the SFC used the same legal argument as Oracle.

Perhaps it is an evil plot to get that ruling overturned by presenting an obviously beneficial counterexample?

Hmm. This is an interesting question. Who would the copyright holder be in this situation?

Yes but they gave money to the Linux Foundation so that makes it all betterer...

Reply on news.ycombinator.com