Analyzing the legal implications of GitHub Copilot
fossa.com
fossa.com
I don't know if it's really that straightforward. The TOS includes snippets like this in that area:
"This license does not grant GitHub the right to sell Your Content. It also does not grant GitHub the right to otherwise distribute or use Your Content outside of our provision of the Service"
I'm omitting other language, but if you read that area of the TOS, they seem to have purposefully scoped down their license-to-use for hosting, backups, etc.
The ONLY available terms are those given by the license, surely?
So if the user uploads the source to GitHub, they agree to the terms (which they may not actually have the rights to) but that isn't equivalent to the rights owner giving GitHub the rights to distribute the source under a different license.
The TOS can only modify those distribution terms (if it even can be found to be legally binding) if the user uploading the source is the rights owner which in so many cases is not the case.
Is it that widely scoped? Can't we narrow it to "A third party who finds their GPL code on Github but has not uploaded that specific code to Github themselves has a right of action limited to that specific code."
Just because I created a github account once and agreed to the TOS doesn't mean that I agree to let others upload my code to github, where would that scope end. Could someone steal code off my computer which i've never published and put it on Github and that was OK because I once signed up for a github account, clearly a contrived example but.
And here is exactly the problem.
GitHub seems to be copying copyrighted code left and right and pretend they made it!
No attribution, no license.
They are of course allowed to let their AI study the code, but as "employer" of that AI GitHub/Microsoft has a responsibility if that AI breaks copyright right and left and they as a company pretend the code is theirs to give away.
Beyond that, that's what DMCA takedown requests are for. Github would only be an accomplice in that case, if they got a legitimate DMCA takedown request and chose to completely ignore it.
I can't find where in the TOS it says that you must "have all the rights [to the code]". It just says that you must not violate copyright nor other laws.[1] FOSS licenses by definition permit redistribution, so uploading to GitHub seems to be in-line with the license granted by the copyright holders.
What are the violations you mention?
> Contributors who add to existing GitHub projects are providing the same license to GitHub as the project maintainer though per the TOS.
Sure, but that's not the only way. If you contribute to a FOSS project elsewhere, those changes go under the same license of the project. Whoever you pass those changes to has liberty to redistribute per the terms of the license. The TOS is unneeded to legally redistribute FOSS-licensed projects with GitHub.
The TOS saying that you must grant GitHub these permissions is only to protect GitHub in cases where people upload projects without licenses.
[1] in addition to content restrictions, like no porn.
Uploading to GitHub is not just redistribution, it’s relicensing. Whether that is permitted depends on the license.
> If you upload Content that already comes with a license granting GitHub the permissions we need to run our Service, no additional license is required.
[1] https://docs.github.com/en/github/site-policy/github-terms-o...
This is a huge legal mess and its not being used to IMPROVE Github products and ops, it IS the Github product.
>It also does not grant GitHub the right to otherwise distribute or use Your Content
I'm curious. Copilot isn't actually part of github. It's a plugin for Visual Studio wouldn't that mean copilot is distributing code hosted on github, outside of github? You can't use copilot without visual studio.
How is this not Microsoft just parasitizing all the code hosted on github to make visual studio better? Which as far as i know, depsite being owned by Microsoft is not actually part of github.
> 'GitHub,' 'We,' and 'Us' refer to GitHub, Inc., as well as our affiliates, directors, subsidiaries, contractors, licensors, officers, agents, and employees.
Does that also include OpenAI? Does it include the Visual Studio team? All of Microsoft?
The license granted by users to Github is:
> We need the legal right to do things like host Your Content, publish it, and share it. You grant us and our legal successors the right to store, archive, parse, and display Your Content, and make incidental copies, as necessary to provide the Service, including improving the Service over time. This license includes the right to do things like copy it to our database and make backups; show it to you and other users; parse it into a search index or otherwise analyze it on our servers; share it with other users; and perform it, in case Your Content is something like music or video.
> This license does not grant GitHub the right to sell Your Content. It also does not grant GitHub the right to otherwise distribute or use Your Content outside of our provision of the Service...
IANAL, but naively, Github appears to be a code hosting platform. If they need to analyze my code to make it work with Git and with their code hosting features, that makes sense. For example, they might have a feature to prevent inadvertent commits of private keys, and would need to parse my code to do so. Maybe my code contains stuff that doesn't work with their generic private-key-finding parser, and they need to specifically run a subset of my code on their platform through their parser in a debugger to fix the feature. That's a sensible license to grant to a code hosting platform, they're not a no-knowledge encrypted storage provider.
They don't appear to be a software vendor that sells code to other private parties for use in closed-source applications. Their license appears to specifically deny them the right to sell snippets of my code to others.
I suspect, however, that this isn't a black-and-white factual issue, rather, one for a court to decide. One could probably hire an attorney to argue any possible angle on the legality of Copilot. And by a similar mechanism to the "Winner's curse", the company who developed a tool like Copilot would always have been one where their internal counsel advised them that what they were doing was totally legal.
Also, for the part about small snippets being non copyrightable. I would suggest looking at the Google/Oracle case. Google was found guilty of infringement for a very small number of lines, but the award to Oracle was IIRC rather a joke (something like one dollar, indicating it was infringing but largely irrelevant).
Tangibly, how is this AI method substantially different from non-clean-room implementations?
In terms of business use, it seems incredibly risky to me to even just *use* GitHub since their license agreement/ToS permit them to use my code to improve their tools which now apparently includes tooling where it may copy your code wholesale as someone else's suggestion.
The difference between that and having an AI do it is probably low. My gut instinct is that using an AI constitutes "access" to the AI's training corpus, so if it spits out something at least substantially similar to that corpus, then I'm infringing if I use that output. If it doesn't constitute access, then a copyright owner would have to prove "striking similarity", which would really only cover things like using Copilot to spit out fragments of old Quake code verbatim.
Clean-room is a way of arguing down the level of access that you have to something that you want to make a non-infringing copy of. It usually requires having actual attorneys review everything the clean-room engineers get to see, and stripping out the parts that are actually copyrightable. Merely training an ML system on input as a way to only have access to the uncopyrightable parts of that input probably wouldn't work.
Pretty much every Internet service is going to have similar clauses to GitHub's; because anything else would basically be a "click here to make me liable for copyright infringement" button. In fact, I wouldn't be surprised that merely running something like GitHub but without a ToS would still give you similar levels of implied license over whatever people push to your server.
The specific part of their ToS I was talking about was the (paraphrasing) [we can use your code to improve our tools and services] part.
It gets worse. To the extent that it is that straightforward, the correct takeaway is that you do not have permission to include someone else's GPLed code in your Github repository.
And that to the extent that GitHub relies on that permission in using the code that they host, they are liable for potential copyright claims from copyright owners that they have no relationship with, who never gave GitHub permission to use that code.
I therefore think that GitHub should do some careful thinking about how much they can rely on a ToS to do as they want with the copyleft code that they host. And I further think that people who host GPLed projects should ask whether GitHub is where they should be hosting those projects.
(Insert the mandatory, "I am not a lawyer and this is not legal advice.")
Or to put that differently;
Using GitHub’s built-in “Fork” feature is probably often a violation of GitHub’s terms of use.
CoPilot is a NEW product, not an existing product (Github itself) that the ToS gives permission to improve.
This doesn't sound right. Alice writes code, and releases it under some restrictive license (GPL, something source-available, etc). Bob uploads it to GitHub, correctly labeled as GPL. Regardless of GitHub's TOS, Bob isn't able to give GitHub any additional rights to the code beyond what Alice gave him.
I think the later discussion about whether this falls under Fair Use is the important question.
If they're taken to court and that part of the TOS is relevant to the issue, then yes, they can and will argue exactly that.
In Norway I think the rule is often "is aware of it or should have been aware of it".
> I haven't heard of Google being sued when play store cards are used by fraud victims.
Banks try to prevent cards from being abused and I guess Google try to. For example when someone tried to buy jewelry in an American store with my stolen card number the card was immediately locked.
Sometimes something slips through though and banks won't be held accountable for that.
The difference here is that there is no way GitHub cannot be aware that people upload personal projects from EU and copies of open source projects etc without agreement from the copyright holder. Besides the easily missed clause in the terms there is nothing to prevent it. Now if they'd done any reasonable effort to inform about it: a couple of blog posts over the years, a "Please note:" banner, even mentioning it in discussions here on HN before doing this that would have counted to their defense.
As far as I am aware no such thing happened.
What about all of the code that existed before Microsoft purchased them and before new licease language was introduced?
Which is the point of the article a bit. GitHub is likely not infringing but it’s also not absolving the end user of any infringement. Neat trick.
That being said I think the risk is minimal enough that I’d be pretty comfortable with using it.
And in EU, as a consumer, you can pretty much ignore most EULAs because they aren't valid if they break EU consumer protections.
Now if your interpretation is correct the idea of a meeting of minds falls completely on its face.
And, as a lot of individuals also upload their projects to GitHub, GitHub is on shaky ground there as well.
I think most EULAs have clauses like these in them but we are always told that it is because of crazy American lawyers and nothing to worry about.
If Microsoft decides to prove once and for all that we should worry about ridiculously broad claims in EULAs I think it will be hard for GitHub to continue to operate in more sane jurisdictions.
HN is not law school and you would be well-advised not to treat it as one. There's a ton of false information about the law flying around here and not nearly enough educated people or time to correct it all. If you want to know the law, go to law school, or ask a practicing lawyer.
> HN is not law school and you would be well-advised not to treat it as one. There's a ton of false information about the law flying around here and not nearly enough educated people or time to correct it all.
Since I learned the exact same thing about contracts being supposed to be a “meeting of the minds” in the first week of Contracts in law school (and much of the rest of Contracts was rules that have been developed operationalizing that principle), while I would agree with your “HN is not law school...” rant as a general rule, I don’t think its germane to the quoted statement.
This is probably an extremely stupid question as I'm neither a lawyer nor an ML dev (merely an humble backend developer), but let's say that the above situation applies and that Github has taken down Bob's repo as per Alice's DMCA request. However, let's say that in between Bob uploading the offending code and Alice submitting the DMCA request, Github used Bob's repo as part of a training set for Copilot. Now that they've complied with the takedown request, does Github have to restore Copilot to an earlier state that hadn't yet been trained by Bob's repo? Does this question even make sense since I only know the absolute barest bones of ML?
It takes some amount of time to comply with a takedown notice. For example, time passes between receiving Alice's notice and taking down Bob's repo.
I would expect Copilot's model(s) to be retrained periodically in order to remain relevant. The next retraining could exclude Alice's code. That might be a longer window than the case of the repo takedown, but as long as it doesn't take too long they might be okay?
There are incremental training approaches that evolve models over time rather than completely retraining them. In my experience, complete retraining is a far more common approach because the highly path dependent nature of incremental training can lead to outcomes that are hard to manage. For example, what if you discover bad training data like repos that collect anti-patterns? Or Alice's takedown notice? You typically want your models to be able to "unsee" things and that's hard with purely incremental training. Even when incremental approaches are used, there is often an occasional complete retraining to overcome such issues.
To be clear, I have no idea what training approach is used for Copilot.
GH's ToS don't prevent Bob uploading content Bob doesn't own. The ToS does require Bob to grant GH a licence to use any content uploaded that Bob owns. It doesn't prevent Bob uploading others' content nor does it ask Bob to grant GH licence to it.
---
If you're reading the ToS yourself, the keyword to look out for is "Your Content", which is defined in their Definitions section as such:
> “User-Generated Content” is Content, written or otherwise, created or uploaded by our Users.
> "Your Content" is Content that you create or own.
The licence grant to GH is only on "Your Content", not on "User-Generated Content" (i.e. content you upload, which may be yours or someone else's)
A) Google Books produces verbatim results 100% of the time, while Microsoft's Copilot produces verbatim results some N > 0% of the time (with some % of results greater than N that would be considered a derivative if a human wrote it), and
B) Google Books doesn't make the claim that you own the copyright to any greater than 0% of the search results, while Microsoft's Copilot makes the claim that you own the copyright to 100% of the results.
You can compare Github itself with Google Books, but not copilot.
Mostly because if you don't do so, that's a plagiarism issue which the law mostly doesn't concern itself with except insofar as an attributed quote, unless the length is truly excessive, is likely to be seen as Fair Use while an unattributed quote, especially if it's more than a minimal snip, is not. (IANAL, etc.)
That's the point I was trying to make, sorry if that wasn't clear. The parallel that I was trying to highlight is that it's not magically your code just because it was hosted on Microsoft Copilot.
Take for example a human. If I studied a bunch of different open-source projects, learned techniques from them, and implemented them in my own projects, is that a derivative work? Probably not. But if I were to reverse engineer Windows and implement the techniques I saw in ReactOS, that's where it seems issues start to arise.
Sounds good in theory, until it starts producing snippets verbatim from uniquely-identifiable sources.
That's pretty unclear actually. If it's quite close to the original work, it is derivative. Even though you have probably been "trained" on quite a few different codebases over the years. Hence the existence of clean-room implementations, wherein the people building a new implementation have never seen the original.
Also, given that code that has been passed through a biological network (ie, brain) can constitute infringement, it seems obvious that code passed through a mechanical one could too. Maybe not in every case, but it certainly seems plausible.
A human being can understand abstract concepts and reason about them based on material they learn from. An ML model is a statistical model that is closer to compilation or lossy encoding or compression.
Often, ML models can encode their training data verbatim in the model itself, which is exactly what happened with Copilot and this example[1].
[1] https://twitter.com/mitsuhiko/status/1410886329924194309
So while it would not be a legal precedent, it would be a social one that would be fought against by other companies.
At the risk of adding another uneducated voice onto this legal discussion - the law is not written like code. Judges can absolutely say "hey asshole, we know exactly what you are doing" even though engineers like to imagine that all situations that use the same technical processes will be handled in precisely the same manner.
The point of my hypothetical wasn't to whitewash stealing Microsoft code in some kind of legal quirk. It was to point out that if learning the structure of code with this kind of ML model is fair use then doing so with Microsoft copyrights is also useful for other purposes. And if Microsoft themselves think that is ok it would actually be a strong argument in this discussion. I suspect they don't and was pointing that out.
That's analogous to training, where there are associations between things, in my mind. I don't think that means they can provide licensed code verbatim though, just as you should not copy GPL code directly out of a Github repo and paste into your own private commercial code base.
If an algorithm of some sort scans a bunch of repos regarding video encoding and decoding and sees a lot of ffmpeg use, it might associate ffmpeg with video encoding and decoding, and decide to present some info about ffmpeg and a generic snippet to include ffmpeg as a library and initialize it if it associates the current project with that.
If I have perused a few encoding or decoding repos at some point and I think of the current project as having to do with encoding or decoding of video, I might immediately think ffmpeg even if I've never used it in a project as a library because I remembered seeing it in projects that used it, and look for some initialization code.
In what ways are these materially different? What makes the random conceptual associations in my head from what I've seen previously different than an algorithm that collects the same?
> Training models is more analogous to compilation or lossy encoding or compression.
And learning in people isn't? Isn't all knowledge transference in people analogous to lossy encoding and compression?
I don't know about you, but in college I don't remember regurgitating sections of "Advanced Programming in the UNIX Environment" to complete assignments, I remember studying it, internalizing parts of it on a conceptual level (as well as remembering specific fairly small chunks almost exactly), and using that to solve problems or answer questions or make associations.
I'm not saying ML and and learning in humans is the same. I do think for the very specific case presented here in how it's used, there are some parallels. Feel free to disabuse me of that notion if you have evidence that contradicts it though. I'm not wedded to that position, but I would want to see arguments to the contrary before abandoning it.
Pretty concerning that this fairly obvious oversight was missed by an IP lawyer consulted by a platform apparently dedicated to managing open-source code.
Github's own ToS makes explicit & careful distinction between code you upload and code you own.
Is it ethical to do this, when some licenses are clearly chosen because of e.g. attribution or sharing improvements? Did Microsoft/GitHub consider the ethical implications, for example a chilling effect on code being open sourced in future (i.e. people choosing not to open source stuff so it doesn't get gobbled up by Copilot et al.)?
However, as a dev I can think about it and say "to me, this is immoral and unethical", and refuse to use Copilot, not work for any company that uses Copilot, not use GitHub/Microsoft products, pull code from GitHub (if I had any), and decide not to open source stuff in future. Ethics has always been underemphasised in software compared to other engineering disciplines.
Generally, non-technical people are (more) impacted by ML, but in this case it's us as developers and our open source communities. So I hope devs will give it some thought this time. And if this leads to devs thinking about ML more carefully in general, great. Things don't have to be illegal to be unethical.
Let's ignore whether GPL or whatever license allows GitHub to do this - let the lawyers sort this out. Instead we should focus on whether it is possible to legally prevent such behavior via license.
In other words, where is my GPLv4 with anti-ml clause?
To the extent that training a model is fair use, it will always trump your license.
Fair use essentially means you can use the work without a license. As long as its ‘fair’. The license might literally say ‘no fair use’, but if you’re not abiding by the terms of the license it means nothing.
You can put anything in a license you want, but it doesn’t mean it will stand up in a court of law.
As the article notes, longer and more complex blocks of code are most likely copyrightable.
> GitHub reports that Copilot is mostly producing brand-new material, only regurgitating copies of learned code 0.1% of the time.
For me, the issue is one of risk. Let's say that you have 100 developers at your company making software for you and they decide that Copilot is great. 1 in 1,000 suggestions is regurgitated code verbatim. Let's say that only 1 in 10 of those suggestions is sufficiently long and complex enough that it warrants copyright protection. Within a week, you'd have to assume that you have dozens of copyrighted pieces of code in your codebase. The big issue is that you now don't know where the code came from and which pieces might be direct copies. It opens up a bit of a can of worms for a company looking to avoid risk.
I think one of the pieces that might get overlooked is someone trying to weaponize Copilot. For example, Wikipedia has seen people upload creative-commons licensed media to Wikipedia and then become very litigious against people who might be slightly off in the attribution requirements. Attribution requirements are often more complicated than just "provide whatever attribution you think makes sense." The images are legitimately creative-commons licensed, but if someone doesn't provide the correct attribution, they sue them. This attribution can include the documentation of the modifications made, author, link, link to the license (which I think a lot of people forget), copyright notice, etc.
https://news.ycombinator.com/item?id=27606035
I don't think most people are looking to be copyright trolls. However, Copilot offers a neat little way to potentially inject your code into other people's programs. Will people start searching for uses of their code and use it as a form of copyright trolling? I don't think most people will, but we've seen it happen with patents and images.
If you have a hundred engineers creating dozens of co-pilot suggested blocks per day, we're talking around a million blocks in a year. I don't think the odds of any individual suggested block being a problem are high. The issue is when you start scaling that up. If we're talking about a large company, the risk can start getting large. You don't know where the code came from and it starts getting likely that verbatim pieces of someone else's code are finding their way into your codebase.
Does Copilot offer enough value to offset this risk? Will future versions of Copilot make sure that the suggestions are sufficiently different from the training source? Heck, there can even be chicken-and-egg problems where someone claims copyright on a block of code that was generated by Copilot and you then have to prove that your identical code generated by Copilot isn't an infringement. Can you prove "yes, Copilot would have generated that code block before you pushed your code into Github" when they claim "Copilot only generated that code block for you because of our code on Github"? It might not even be a company that's evil doing this. Large companies often have no idea what different parts of the company are doing - especially several years later.
One thing I want to make clear is that this isn't just about cases that would win on their merits. One of the big parts of the Wikipedia discussion on overly-litigious uploaders is that it can cost a lot more to fight infringement claims than they're asking. If someone slaps your startup with a $250 "you stole my copyrighted code" claim, do you hire a lawyer at an hourly rate that might cost more, risk a trial costing tens of thousands, and risk a judgement against you? Or do you pay them off with a small amount of money to make it go away? I'm not saying this is a good situation. I'm just noting that it definitely exists and trolls can try and come after you at the worst times like when you're trying to raise funding. Do you decide to fight it when you're trying to IPO? Do you let the IPO price sink by a few percent and lose you lots of money when they're just looking for $5,000 to go away?
It just seems like adding a lot of risk.
But I think you'd violate Disney's copyright by uploading their pictures to the website.
To make it work, Disney would have to upload the pictures themselves and agree to the TOS.
YouTube will still make money from it for some time (selling ads, luring customers in, ...), then the copyright holder asks YouTube to take it down, and then they take it down.
The difference is that open source authors don't care that much about that. But maybe now they will when they see what GitHub is doing...
YouTube isn't publishing derivative work from the videos it hosts, though, like Microsoft is doing with Copilot and GitHub.
If Copilot was trained on material it doesn't have the license to, it can potentially output that unlicensed code it was trained on, like in this example[1].
Copilot could serve up copyrighted work in the same way YouTube does, but the analogy isn't complete, because YouTube itself isn't a derivative work in the same way the Copilot's model is a derivative of the data it was trained on.
[1] https://twitter.com/mitsuhiko/status/1410886329924194309
Your proposal is just so substantively different from Copilot that I don’t see how the arguments for Copilot would apply.
Even when no GPL v2/3 code is quoted by Copilot, is using the code for training a non-free product allowed under the license? Under the license, is Copilot therefore now licensed GPL v2/3? The GPL code was certainly used to create a critical, integral part of Copilot, and to create its output.
If I understand correctly, GPL v2/3 were designed to prevent non-free products from being parasites on FOSS code, taking and not giving. If that's the spirit of GPL, Copilot seems to clearly violate it.
Sure, that's fine if the author of the code chooses to upload it to GitHub. But what if they don't, and then someone else does? If I take an AGPL project that someone else wrote and upload it to GitHub, does that grant GitHub the right to use the code "to improve their products and features" which are closed source? I don't have the right to relicense the code, and neither does GitHub, so clearly not.
I guess in about 5 years we'll see Softbank v. GitHub CoPilot in the supreme court deciding whether ML can make transformative work.
That statement is wrong.
Github does not know if the uploader of some lines of code is actually the author of said code or otherwise allowed to upload it.
Imagine I uploaded the source code of Microsoft Windows to Github.
The Github ToS can force users to grant them whatever they want, but I am legally unable to grant them any usage rights for the Microsoft Windows code that I uploaded.
There will be many cases of people uploading code, including open source code, from elsewhere to Github, and the original author not caring or whatever (e.g. informal mirrors), where the uploader is unable to grant Github any rights.
These people either think that for ideological reasons everything should be on GitHub or they want Google links to their companies.
Furthermore "improve their services" reasonably only applies to their core service that was present when people agreed to the TOS and not to some new code laundering AI.
It is frightening that this matter could be decided by such lawyers in the US. People should just all leave GitHub, then Microsoft can play with its own AI and enjoy the silence.
Looking at the source code or the function and variable names in binaries, you cannot tell if CoPilot is used or not, so there isn't a functional difference between someone copying that code or CoPilot copying it.
The problem is, I don't think you can really claim that Copilot learned to program. While some of the output seems to be something new, most of the times it looks more like a recomposition of learned fragments if not even longer pieces of verbatim code taken from copyrighted material. We have seen examples of this. And in this moment, it becomes a copyright discussion, probably determined by the volume of copyrighted material reproduced. Which by the way is always the risk if a human uses certain training material. The better one is at memorizing things, the more there is the risk.
Or put it the other way around: if Copilot would use its "knowledge" of programs to advise the programmer like pointing out potential errors without reproducing anything it used for learning, it should be fine. But that is not how it works.
What if an algorithm does the same? The result is 'a recomposition of learned fragments' in either case.
With the AI it is not clear, that there is an abstract lerning beyond building certain memories.
[1]: https://media.geeksforgeeks.org/wp-content/uploads/202003171...
[2]: https://www.geeksforgeeks.org/ml-face-recognition-using-eige...
GitHub's Terms of Service doesn't override licensing terms.
This only applies to work you have exclusive ownership over (and GH's ToS are explicit about this). You don't (legally can't) grant GH any rights to work you don't own. But you can still upload it (e.g. forked open-source code).
SwiftKey is kind of magically good without being - to the best of my knowledge - a plagiarizing or creepy thing.
You can have some fun by feeding it a start of the sentence but to the best of my knowledge it won't autocomplete a full stanza from a famous poem or the first two paragraphs from a best seller or anything like that.
It also learns from me but stores what it learns from me connected only to my account. Again as far as I know: this is based on my reading of the user agreement but also on how it lacks a lot of instant messaging language and stays reasonably formal.
That is how it should be.
If copilot was like that many more people would find it acceptable.
Not as straightforward as they think thou.
If a code project used (a)gpl code found elsewhere on the internet in their repo, and another user took the project and hosted it on github, the tos can not give github a license to use the code outside of the license given by (a)gpl, even if github thinks they have one, that won't shield them from legal liability, nor will it shield co-pilot users from being legally compelled to (a)gpl their code if a court case was won on those grounds.
The github tos is basically a non-factor in this case.
I contribute my code to X project outside of github (say on a mailing list) under the explicit understand that my code is under GPL (say GPLv3 to be specific). If someone later uploads my code to github and github uses my code to train their ML model in violation of GPLv3 isn't the point that the person who uploaded my code to github is in violation of GPL by giving it to someone else under less restrictive terms?
Does this mean that the github terms of service are perhaps fundamentally incompatible with uploading copyleft-style (or perhaps specifically only GPLv3 level) restrictive licenses?
And, if so, probably they always were but nobody cared until now.
I assume it's a pile of rubbish that's currently fooling Youtube hype based programmers and followers. Has any ok but real programmer used it solid for a week yet and wants to keep going?
This is tied to the legal argument.
If Copilot works (Which I cannot believe it would) it changes many legal points. Garbage spewing out copyright code is different to something that 'understands' copyright code.
And who cares about copyright if it's like all other hype based AI currently, unusable in the real world. All the current HN seems to be bike shedding around legal. Does noone program anymore?
Legal? Probably. Should we do better? Probably.
At the very least, it should be opt-in. We'll probably need new IP law to make this kind of thing opt-in.
Fair use seems to be a legal concept that mostly only exists in the anglosphere. How will this be in the many other countries, then?
This seems like a problem similar to explainable AI.
Kind of like Spotify works for artists.
how is "use common sense" even remotely a meaningful thing
It’s kinda surprising Copilot even reads and outputs comments.