Just because you’ve made something cool doesn’t give you the right to harm others in the process.
If MS or OpenAI don’t think this is the case then they should have also included their private repositories.
Is fair use on a massive scale still fair use? Courts generally think so, otherwise Google would have been out of business a long time ago.
They are doing this to make sure that any lawsuit can be easily dismissed. It has nothing to do with the legality of the action (which sounds like fair use as the parent described it), and everything to do with the expense of a potential lawsuit compared to the cost effectiveness of simply telling developers “don’t do that”.
Most people think that the law has two shades: lawful vs unlawful. But the more practical distinction is expensive lawsuit vs dismissed lawsuit. This is the lens through which corporate lawyers see copyright and it might explain why so many programmers think that copilot is “obviously” breaking the law and “stealing” their code.
Questions of derivative works and fair use come up fairly frequently even in the open source world. This isn't solely a question of corporate lawyer posturing. I don't know any copyleft authors that would be okay with someone copying & pasting their code, making trivial changes, and saying it isn't a derivative work. Of course, their understanding of the law may be flawed. You'll get to find out in court.
You're right. A lot of this boils down to how much you want to spend in court proving your usage is just under fair use. We've moved beyond the question of ethics if you're intentionally violating a project's source license and relying on fair use to do whatever you want with the code. If you want to poke someone with a stick, you can't be surprised when they hit back. I contend what the OP described isn't clearly fair use (note I'm not saying that it clearly isn't fair use either). It ultimately doesn't impact me because I'm just not going to copy & paste code from projects without attribution and following the license, but I'd be worried about anyone reading that comment as objectively true.
Courts have held that it doesn't apply to music, why do you think different rules apply to code?
Songs are different from code, in that the “hook” that makes the money may be only a few seconds long. There are many creative choices that a songwriter/producer can fit into just a few seconds: the harmony, melody, rhythm, lyrics, timbre, effects, ...
Whereas for code, the space of creativity is limited by functional considerations. A creative choice is protected by copyright but not all choices that programmers make are creative. Often the choices are limited by the API/interface or by efficiency considerations and it turns out that there’s only one good way to do something.
A function may be very intricate, yes, while still containing almost no creative value (e.g. a Vulkan setup function). Music doesn’t have an equivalent to this - the placement of every note is a creative act.
Yes, I too, and probably many people will do.
> In fact sometimes I copy and paste short passages and then rework them.
This I usually don't unless I check the license first. (Everybody ought to be allowed, but sometimes the license might not be.)
It reminds me of the Google vs Oracle case. Apparently a court found that copying even a small amount of code in breach of its licence is not permitted. [0]
[0] https://en.wikipedia.org/wiki/Google_LLC_v._Oracle_America,_.... (ctrl-f for de minimis)
On the other hand, if you copy from private repositories, it quickly gets into the territory of stealing trade secrets.
"Microsoft does it, therefore it must be right" does not a sound argument make.
No, businesses are — not business. Not necessarily...
Also, the open source community has far less leverage to apply pressure to Google than it does to GitHub. We may be able to do something about this.
The whole point of fair use is that the license doesn't matter. You can have a license that says I'm not allowed to use what you wrote for any purpose ever and I can still use it under fair use.
That said, copilot itself is not a replacement for your open source project that it was trained on. The code it generates may or may not be, but that's probably not Github's problem as far as copyright law is concerned.
I don't really think this argument passes muster.
It's just automating the copying and pasting (and slight reworking) of boilerplate code that would normally take me much longer to do, especially when I am working with a language I'm less familiar with but is necessary for my stack. I've literally never seen it suggest code that is more or less almost exactly what I would have come up with given a lot more time. In essence, it eliminates tedium- exactly the point of all of programming: Work elimination.
I have two questions:
1. Why have licenses, then?
2. What if I just use leaked sources of closed source software and call it fair use?
The default under copyright law is that any substantial copy is infringement.
A license is a legal document that grants someone permission to use a work that they otherwise would not have had.
However the law also gives its own permissions to use a work - it defines what is unlawful infringement and what is lawful fair use.
The code snippets that copilot generates look more like fair use than infringement. They are small, adapted to the destination context, and usually not direct copies of one source but more of an average of many different sources. And usually the programmer does not keep the suggestion that copilot suggests unmodified - the programmer does their own editing of the snippet afterwards to further tune it to the surrounding context.
2. What if I just use leaked sources of closed source software and call it fair use?
As pointed out upthread, if it the source code is leaked then there may be trade secret protections. The GPL specifically allows the code to be posted online, so by design it is not secret.
The reverse maybe true. I may be GPL'ing a code to prevent a useful algorithm from being buried deep inside a commercial code with an incompatible license. What makes it a "trade secret" level code? I have a 25 line algorithm which is worthy of its own paper. What if I open its reference implementation with AGPLv3+?
I have no problems with you reading the paper, and implementing it. I don't obfuscate my papers, but I put the implementation out with AGPLv3+. You can't use that in a codebase with an incompatible license. I expect and want you respect the license of my implementation.
> The code snippets that copilot generates look more like fair use than infringement. They are small, adapted to the destination context, and usually not direct copies of one source but more of an average of many different sources. And usually the programmer does not keep the suggestion that copilot suggests unmodified - the programmer does their own editing of the snippet afterwards to further tune it to the surrounding context.
Emphasis mine. First, there's no consensus on fair use, yet. Second they may be direct copies of the code. Third, they're remixed with other code pieces, which makes it a derivative work of many code pieces at once, then lastly, programmer re-derives the derived work. Which is clearly a derivative of GPL code, which brings in GPL license with itself (if what copilot derives the code from GPL licensed repositories, which it does).
I have no problem with Copilot as a technology. I have no problems with other licenses, which are not breached when used by Copilot and derived and used. The point which makes my blood boil is copilot using this GPL corpus, and don't admitting it publicly, breaching the terms of GPL en masse, and outright ignoring it. Then feeding this GPL derived code to any and all projects which pay for a copilot membership, and calling it a day.
I do think there are ethical questions around whether it's right for google to digitise physical books without the permission of the authors, and keep them on their servers and make money from them without recompensing the authors. That's something an individual would not get away with doing, so it seems wrong that it's OK for google.
The SCO vs IBM lawsuit was over only a few lines of code, after all.
I cant use a derivative of Mickey Mouse in my product, even if I change his colour and give him a hat, even if these changes were made by an AI. Why would it be different for code? I cab only use Mickey Mouse as fair use if its done for a specific barrow set of proposes (satire, news reporting etc).
There are just minor deviances, not relevant to this case, such as how long Disney bullied the countries to protect a work.
Software is usually considered a work. The AI needs to know if has permissions to copy and use the code, and then offer derived work on the proper terms and conditions. copilot doesn't do that. It might copy GPL code into non-GPL code, thus violating the GPL license, thus being an extreme risk.
In the US there have only been two extensions of copyright terms since Disney came into existence.
The first was in 1976, as part of a major overhaul of US copyright law to update the previous law (from 1909) to take into account the large changes in technology since then, and to make US law work more like the rest of the world to pave the way for the US later joining the Berne Convention. The changes for Berne compatibility included longer terms.
I assume Disney did support this, but only because as far as I can tell it had pretty widespread support. It had enough support that it would have passed even if Disney had adamantly opposed it.
The second was in 1998, and that was specifically a term expansion (as opposed to a term expansion like that of 1976 that was a side effect of harmonizing US law with the rest of the world). Europe had expanded terms a few years earlier, so the 1998 change in the US might have been motivated at least in part by harmonization, but I don't think the differences in terms between the US and the EU would have been enough to get it passed without some major interests pushing for it, so it is probably fair to give Disney a good part of the credit or blame for this one.
Here you see the countries which did not extend it the 2nd time to 70 years. https://en.wikipedia.org/wiki/List_of_countries%27_copyright...
There was of course no widespread support for these extensions, as all its arguments were flawed and not only violated logic but also several constitutions. https://de.wikipedia.org/wiki/Copyright_Term_Extension_Act#G... (the en version is mostly cleaned on these counter arguments)
I don't think that will happen but it might be interesting if it did.
I would like to point you to this: https://twitter.com/mitsuhiko/status/1410886329924194309 HN Comments at the time: https://news.ycombinator.com/item?id=27710287
This is the end of Microsoft's actual calculation.
I don't think you can have your cake and eat it on this one.
It's kinda shocking that they think they can sell this, even providing it for free is extremely sketchy but at least complies with BSD/GNU/CC licensed stuff I guess.
Is every product user liable when a vendor ships some stolen code?
The user would be unlicensed, and in lieu of the vendor resolving this then the user would need to purchase licences to continue using the software legally (ie if a vendor gives you a pirate version of photoshop, you can’t just use it forever just because someone sold it to you).
There are usually clauses in enterprise software agreements that attribute liability for unlicenced components to the vendor for this reason. But ultimately if there isn’t a contract or the vendor vanishes, the user will need to go get a licence.
If you want to test the theory, I’ll send you a few images to put on your website, and when you get a claim through from the copyright owner you can try to argue that I sent it across without a copyright notice so I am liable ;)
No, but the difference is the users of a product are typically not making and distributing copies. That’s not the case if you use someone else’s code in your project.
That's not what copyright is protecting.
I believe github's lawyers would have had hundreds of hours of dicussion about this and at this point, they believe they are in the right, and anybody who disagrees should use the legal system to resolve the matter.
In the meantime, what it is and isn't doing wrt licenses seems to be poorly understood externally.
All they could do is filter by the LICENSE file in the repo.
Unfortunately for them, by law copyright and license are determined by the authors and merely represented by a LICENSE file, which could be lying about both.
The court isn't going to accept that excuse when this goes to trial.
It's hard enough for us human to find our way in this mess, I've little hope for an AI.
But maybe it's just the first step. The final step being able to sell an AI that understands Copyright management. I'm sure there is a big market for that.
1) Require each repository to opt-in to be learned from.
2) Require any source file used for learning to have an SPDX license heading.
3) Have a list of approved permissive licenses to avoid any proprietary or copyleft arguments.
Using SPDX headings as the explicit guide would solve the problem of different code content using a different license within a project. An example being QtWayland: the client pieces are Proprietary/LGPL/GPL, whereas the compositor parts are Proprietary/GPL. That's not something you'd know from the license files at the root of the project (and post-6.3 they use SPDX instead of the prior license template heading).
Granted, this doesn't solve the problem of the chain of trust (is the individual publishing the code truly the copyright owner), but I think it would be a basic start for a program like this. The opt-in nature would make things... difficult, but I think that's a fair trade-off for something like this.
But until lawyers push for a standard that would make this part of their work irrelevant, I can't see how it could happen :)
Permissive or not doesn't matter. Public Domain or not is what matters. Permissive licenses still require you to propagate the copyright notice, which Copilot strips.
https://jtip.law.northwestern.edu/2021/05/28/copyright-issue...
However, even if infringement occurs during machine learning, training AI with copyrighted works would likely be excused by the ‘fair use’ doctrine.[ii] For example, in Authors Guild v. Google, Inc.[iii], Google had scanned digital copies of books and established a publicly available search function. The plaintiffs alleged that this constituted infringement of copyrights. The Second Circuit held that Google’s works were non-infringing fair uses because the purpose of the copying was highly transformative, the public display of text was limited, and the revelations did not provide a significant market substitute for the protected aspects of the originals.
The Second Circuit's tests listed in your citation specifically fail in this case. It's not highly transformative since it's just regurgitating snippets to be used in other competing works rather than applying the body of works to a different domain. And it's specifically to provide a market substitute for the protected aspects of the original works.
Additionally, none of this says 'its all great and it's on the user to figure it out'.
> the revelations did not provide a significant market substitute for the protected aspects of the originals.
test of your cited case law though. The courts clearly drew a line at developing AI to inject snippets of copy-written works in similar copy-written works. And in context it would be the developer of the AI at fault (in addition to the end users who also used it to infringe other works in the creation of partially derived works; multiple parties can be at fault).
Basically the courts are making it pretty clear that they would have been against what Google had made if it were suggesting phrases in a plugin for a word processing program to create books that would compete with the original books. But being a separate domain of simply collating existing books and providing better search for their corpus (which led you to the original) was allowed.
Unfortunately not. It's really stupid.
Lots of companies do not put their code in public repositories, granted I understand the perspective of violating a license, but the point is if you don’t want your code used by someone else (even with the risk of not getting credit, don’t know why that matters) then don’t make your repo public period.
To that point, what’s to stop GitHub from making a policy that states: “All public repositories will be utilized in AI training”?
The point is that it’s not respecting the license, not just that it’s not giving “credit”. If I release code under a GPL license, I damn well don’t want someone using that code under a license that’s not GPL-compatible, no matter how it got there.
def average(*numbers):
return sum(numbers)/len(numbers)
That's as simple as that.
The point I'm trying to make is if something is under a copyleft license, you can't copy and paste it verbatim to something non-copyleft. It's what the license says.
Also, to be pedantic, the function I'm commenting on is pure maths, and you can't license/patent mathematics.
On the other hand, if there's some magic sauce of doing something, let it be 25 lines, what will you say? It's just 25 lines, so you can't license it? To be more pedantic, I actually have an algorithm, which is around 25 lines and does something novel. I've published a paper on it.
If I license the reference implementation with AGPLv3+, and you use it and close it, and if I can't go after you, what's the purpose of the license?
You can read the paper and try to implement it. It's free in that regard.
Isn’t there already precedent in other forms of IP, such as chord progressions in music, sentence length in literature, etc?
Is it again too trivial?
I don't know. That's my function's length.
> do you count comments?
No comments, no blank lines.
> can I codegolf a few lines to get below the limit?
You bet. But, if you copy my reference implementation, you need to get the license as well.
However, the research is on the open. Read it, implement it. That's no problem.
But, CoPilot is not reading my paper. It's reproducing my function verbatim, which is under a license which has share-alike mechanics.
There are no rules about the form of the code itself that governs whether or not someone owns it. Common sense applies. Sure you could "steal" very small, common, code snippets and get away with it; but that doesnt make it less wrong.
When a commercial entity explicitly does it, however, some times we can catch them. Like if they do it through algorithms that we more or less know how they work - i.e. the algorithm is using advanced control flow logic to copy and paste from it's training data set and copyrighted material is in that data set
Copyright really is not only concerned with what exactly is on the page, but also how you got there, and where the knowledge came from to get you there.
What if I read your codebase, and then years later while programming for myself I inadvertently use solutions you came up with while thinking I came up with it myself?
There really are no hard set rules, and this is something that is handled on a case-by-case basis based on whether or not a convincing argument can be made that you copied a novel idea from someone else and claimed it as your own.
We can argue the semantics of it all we want, but the subject area is an active battleground. Typically it only matters when money starts to get involved, since no one usually presses the issue or gets involved with random personal projects. So when an enterprise level company leverages that lack of caring into a proprietary pay-to-use project that operates by copying and pasting code from copyrighted material, then it seems like a case might be able to be made for it.
OSS knights: THE LICENSE.
MS: Aight, I guess we have a few lines of hq src to help out with…
Github: Same.
Other OSS people: We really don't care one way or the other.
As long as the word of the lincense was upheld for another 2 weeks before it ceased to matter for the rest of all time.
Jesus fucking christ. People. I get that oss licensing is dear to the collective hn heart – but, at best, it's completely irrelevant in regards to where this will inevitably lead, regardless of current questions/issues with license violations. You can (if all the repos of MS and Github are not enough to train this thing on, which is a laughable idea) even fucking buy additional source code if that's what it takes to strengthen Copilots legal foundation. The cost is insignificant. People will be happy to sell for super cheap. It's a non issue.
Why do you wilfully choose to be distracted instead of facing and thinking about the future together?
Something being cool doesn't exempt it from discussion of its ethics and certainly doesn't exempt it from legal consequences. Often what people call "disruption" is often just exploiting resources/people/their work in unsustainable ways until oversight is introduced.
If CoPilot is copy/pasting large amount of code with unknown licenses, that is a large and real risk for users aside from violating open source projects licenses.
Even including something banal like Linux is already problematic since it's GNU licensed, which by extension makes your entire project GNU licensed and you can't keep the exclusive rights to it.
> since it's GNU licensed, which by extension makes your entire project GNU licensed and you can't keep the exclusive rights to it
This is incorrect. Including GPL code in your product cannot automatically relicense your code. It’s just a copyright violation if your product’s license isn’t GPL-compatible and you don’t abide by the GPL.
Indeed. The heist in Ocean's Eleven was cool, but it was still theft.
Because they shared the code under a license, and they have the right to complain if people use that code but don't follow the license.
For example, what happens if Github Copilot spits a copy of some copyrighted code verbatim? Is laundering open source code through a machine learning model a loophole for not having to follow the license?
Often following the license is as simple as giving credit to the original author.
There are tools that will analyze a codebase and identify where chunks of varying size seem to come from. Mostly to determine if the code is encumbered by problematic licenses, but also to detect where the programmers may have borrowed code from.
If memory serves, some of these companies also have closed source codebases in their database, enabling them to detect if unpublished code has been re-used.
The times I've used this in due diligence it has rarely been a deal-breaker when we do find large chunks of code that may be problematic. For instance due to licensing terms that are not acceptable. You just make a note of it and have them rewrite the code before the transaction can take place. (Or you figure out if you can accomodate the license terms).
It's as if Microsoft were banking on the fact that most violations will be unnoticed
People don’t have a problem that AI is being used in some form to provide the service.
The complaint is pretty clearly that code is being lifted from repositories without attribution or compensation, and being redistributed into other applications.
How impressive the work behind copilot is or is not really isn’t relevant.
If I modify them I know what I have to do, but Co-pilot is somewhere in-between the two, it's abstracting knowledge from these codebases. We don't yet know how to deal with it properly, but this will change with time, that's why having these conversations are important.
I think that AI models will gain a new legal state, whatever they learn will be considered original work if it's not repeating non-trivial work 1:1.
But that's basically all copilot does? It's just a fancy compression system with a search function.
https://twitter.com/ayourtch/status/1539928018138931200 is my experiment. The code in question has a very specific format - it’s C with a lot macro sauce. I described the intent in the comment and pasted the includes lines. Then I started the #define of a unique looking token, and it added the lines with the correct boilerplate. What you see in gray is more boilerplate that it suggests when prompted.
I would dare to assert that “xxxayourtchtestxxx” is not going to be in anyone else’s code than mine.
So you can see the example of copilot generating completely new code.
Not saying it’s 100% of what it does - but this side looks very useful.
I also did a test with Rust: described a function canonicalizing MAC address, and then when it saw ![test] prompts, it started to make very passable unit tests for the function which was not even written yet - it was only the comment of what it would do.
Also a massively useful lever to have, if it can do so consistently.
My attempts to make it generate a bug-free canonicalization function didn’t work - but it was interesting to see it try different approaches based on the existing test code (and no, they didn’t always satisfy the tests, unlike one would expect :)
So this angle is “pair programming with a creative novice”, which also can be useful - it can give ideas to explore that you didn’t think of.
Of course this was all fairly trivial code, I do not know yet how it will behave in a more tricky situation.
Even if it changes the var names and formatting a bit, it's still at best highly derivative. And at worst it spits out the exact code verbatim.
That makes all the difference IMHO, its complexity makes it much more than "just a DB". The synthesis part takes into account the context also, so it does intelligent things automatically, a smart SQL query does not.
My brain also works kinda like this. My knowledge is encoded in an incomprehensible format and I convert my knowledge into code based on the problem at hand.
This is where some modest taxation comes in. To reallocate a slice of the output of value creation to its actual source in a rough kind of way wherever more direct compensation isn't feasible.
You clearly don't know how copyright around sampling works. Yes rappers are paying shitloads to previous generation musicians for samples they use.
And you can bet that SpaceX using physics knowledge and cumulative rocket engineering knowledge are very careful to either license the tech they use or be very explicit about documenting their own.
That you can't see the difference is entirely on you, going 'against the flow' of society sometimes leads to change but more often it simply results in friction and a lack of comprehension.
Keep in mind that open source is based on copyright law, and without copyright law the protections that open source offers would be gone.
To give an extreme example: if you had a chunk of software that was constructed in such a way that it would spit out a complete copy of 'the Gimp' without the license file if you started to write an image processing program that would be a very clear case of copyright violation.
If you then start breaking the Gimp down into smaller and smaller re-usable fractions at some point you might be able to argue that such a generic and oft used snippet should be free of copyright. But that only works as long as you then don't string together a whole pile of pieces that you each copied somewhere else, the whole idea is that your creation is an original one.
Medical research (which quite often leads to patents, which I don't believe should be possible, especially if that research was publicly funded) and physics knowledge are of a different kind than copyrighted program code. The latter would be better compared to universally present language constructs and constraints, such as 'memory management', 'data manipulation' etc. Once you make those explicit in an implementation copyright applies.
Or, to make another analogy: it's like comparing the skill of writing to the product of that skill. The skill isn't protected, but the output of the act of writing is.
They are all in compliance with intellectual property laws? Seriously, that's a bloody big difference.
Co-pilot is not in compliance with many of the source code it is using!
Whether you like it or not, compliance with the law is necessary.
Humans use reasoning. Copilot just guesses the likeliest next word.
See the Quake's fast inverse sqrt code incident: https://twitter.com/mitsuhiko/status/1410886329924194309
I was with you until this statement. The vast majority of society consumes, but doesn't create something new in the process. I'm bewildered as to why you think taxation is a solution rather than a disincentive towards creating. As far as compensating the giants upon whose shoulders most stand, there are plenty of vehicles for that: royalties, patents, copyrights, pensions, awards and prizes, paid fellowships, etc. These are relatively easy to calculate and write a contract for.
No, I won't, because Disney has fancy lawyers, the average open source developer hasn't. What you are saying is: Screw little people, let M$ make their money.
Either copyright is for everyone, or for no one. I prefer the latter, but this is not the world we live in.
It should not be different, or if anything, it should be worse to punish people with less resources. But here we are.
I once heard this quote, "English justice is open to all, in the same way that The Ritz [very expensive hotel] is open to all."
That’s all I ask — if you use my code, give me credit.
Stealing my code to train your bot — which will replicate portions verbatim! — is no different whatsoever than the casual plagiarist that copies and pastes a novel snippet manually.
Its absolutely my legal and ethical prerogative to complain about people stealing my code by failing to respect the license under which it was freely provided.
Reselling other people's content like this without attribution (which, is a pretty mild form of payment) is not nice. But at least you now have one more reason in the list of reasons why Microsoft acquired Github: to be able to launder their open source contributions and resell them.
There are real, serious, and genuinely interesting issues to be discussed regarding Copilot. It is neither "just selling code that other people wrote", nor is it something that we should applaud merely because it demonstrates "human ingenuity".
The comments here regarding this are honestly a total dumpster fire. It's mostly a bunch of paper-thin hot takes, either:
- The blatantly stupid "you willingly shared your code so why are you complaining that one of the world's biggest companies is now hoovering up code from your carefully-selected open-source license and reselling it as a service!!!"
- The blatantly lying "I have literally never looked at any other computer software while developing any obviously anybody who has ever seen other source code is a plagarist"
It's dumb because there is an actual interesting discussion here but I guess we're not going to bother having it.
I actually didn't intend for my comment to be an argument in favour or against, and I am a bit surprised it is the most upvoted of the section.
I agree that there's a pretty interesting discussion to fair-use and the limits of copyright, and that my original comment was not conducive to having that discussion. In my defense, neither was the tweet this thread is about!
Demanding that the law of a country should be followed by another is totally no sense. They can agree, make agreements about it, and even take legal action to the Highest court, so it could be evaluated, but using your nationality as an argument of what you can do, it's just plain wrong.
I always find it weird how people respond to my comments. Why didn't you check what the US law is like for source code? A lot of places have similar laws around source code, primarily in the West because of efforts to normalise laws across countries, driven by US efforts. And other countries? Well, it's the same for any kind of IP. Either the country has strong IP law and you have the resources to pursue an issue or not and you can't do anything about it.
This is nuts. How can anbody be expected to both know that you’re German and German law when you post on an international website?
Or is this a German law that exists to prevent other Germans from doing things but that the rest of the world scoffs at?
This is the legal expectation in general, not just for software - you can't just come across a design for a neat widget somewhere and start using it in your product, there's probably both copyright and patent on it. Software isn't special. Not everything in Github can be copied into your code verbatim.
I put a fucking license on it so that it doesn't get abused by some fucking corporation. Jesus Christ, it's not hard to understand.
I don't make Free software so that Microsoft can sell it to people for use in proprietary projects.
But the world we actually live in is one where corporations have copyright, and individuals don't.
That's what irks people, I think rightly.
People like you should understand that publicly available code doesn't mean "do whatever you want" code.
The majority of publicly available code hosted on Github as a license that tells you what you can and what you cannot do with that code.
If someone uses this code without respecting the license, authors have the right to complain and even legally enforce the license if they want.
Now, you should know that there's nothing "cool" to take other people's work without permission.
That's likely the crux of the issue. If you do it right, you can steal from other people and get rich. Meanwhile, those same people (whose work was stolen) may be left out in the cold no matter how original, creative, hardworking etc they are.
because it's not unconditional, there are often licence terms of usage, and copilot is potentially laundering those.
For other individuals to collaborate, to make the software available to other people, etc. Certainly not for github's profit and much less for the benefit of github's customers who will have access to open code that violates license agreements.
It’s a product by a business. Why is that not open to criticism?
Quake's source code is GPL.
There are plenty more if you're willing to look.
If I, as a human, go to a public repository on Github and copy/paste a non-trivial 200 line code snippet into my proprietary code base I have to abide by the license of that original code, even if I slightly modify it. I don't see how this cannot be true for Copilot. I'm sure the legal folks at Github have thought of a response though, you could e.g. argue that the snippets produced by Copilot are not affected by the copyright of the original author as they do not reach the required treshold of originality. Seems rather shaky for me though.
It is not true. Whenever there is something really useful, everybody is happy, and while of course they always are some nansayers, they're very few.
However, when you do something controversial, you can expect to hear criticism. You are of course free to dismiss that criticism, but when a lot of people are telling you what you are doing is unethical, maybe it's time to stop and think about it.
One big reason I support it is because it grants me the right and ability to change things I need/want to change.
Moreover it is possible to BOTH marvel at the human ingenuity that went into making copilot AND disagree with their methods. Some things can be marvelous and wrong at the same time.
Sorry for the unproductive tone of this comment, but there's something about the attitude of this tweet that really grinds my gears. Any time someone invents something new and incredible, there's always a crowd of negative nancies eager to discredit and explain why the invention is nothing new and a detrement to society. I don't understand why someone would willingly share their code on github where it is publicly available just to complain when others make use of that knowledge. 'co-pilot just sells code other people wrote' is such a ridiculous understatement of what co-pilot does. Instead of marvelling at the human ingenuity that went into creating it, they sneer at the audacity of openAI to do something without first asking their permission.
— This comment brought to you by HN-Comment-AI ©
Although I have to say the use of the phrase 'negative nancies' shows that even the best machine-learning algorithm still comes up with unlikely to occur in real life text.
We fought this battle over a couple of decades with remix culture (“you stole that line/beat out of my song!”) and the world is better because the over-clingers lost.
There is no shortage of reasons not to like copilot, but I don’t consider this one of them.
Think about how Napster was treated back in the day, or torrent websites. You pay to access some copyrighted content. Is it legal ?
It's easy to convince oneself they can only be a professional developer to escape ethical responsibilities which require significant time and energy.
Assuming this is the case, are you concluding they don't have time to be a real software developer?
Maybe they were a professional developer, but now are an activist 50% of the time.
> selling 30$ videos on how to be anti-racist
Is the indictment here that they are a capitalist?
My basic point is you seem to really want to dismiss their views you don't like by arguing they aren't credible rather than attacking their ideas.
No and they are actually anti-capitalist according to their Twitter bio.
> My basic point is you seem to really want to dismiss their views you don't like by arguing they aren't credible rather than attacking their ideas.
The comment I was replying to already did a good job at that, I was just adding some context.
Not bad for everyday use - I like "nattering nabobs of negativism" (as scripted by William Safire), but it is really a bit over the top.
Copilot is NOT SELLING coed other people wrote, it is simply acting as a curator to show you all the solutions people HAVE WRITTEN for free.
Copilot does NOT write entire programs, it's simply an assistant. And there is not much copyright you CAN apply to 3-4 lines of generally understandable code.
I've used Copilot and am actively paying for and I have not seen many cases where it's generating bad code. It's only there to remove boilerplate and common problems, not there to write entire applications.
Why are people getting so salty?
Github knows better, can do better and should.
% Constants
FISRCON GREG #5FE6EB50C7B537A9
THREHAF GREG #3FF8000000000000
% Save half of the original number
OR $2,$0,0
INCH $2,#FFF0
% Bit level hacking
SRU $1,$0,1
SUBU $0,FISRCON,$1
% First iteration
FMUL $1,$2,$0
FMUL $1,$1,$0
FSUB $1,THREHAF,$1
FMUL $0,$0,$1
% Second iteration
FMUL $1,$2,$0
FMUL $1,$1,$0
FSUB $1,THREHAF,$1
FMUL $0,$0,$1
(This comment and the MMIX code it contains, and all other comments that I wrote on here, are I agree release it to public domain.)
Any time someone invents something new and incredible, there's always a crowd of negative nancies eager to discredit and explain why the invention is nothing new and a detrement to society.
I don't understand why someone would willingly share their code on github where it is publicly available just to complain when others make use of that knowledge.
'co-pilot just sells code other people wrote' is such a ridiculous understatement of what co-pilot does. Instead of marvelling at the human ingenuity that went into creating it, they sneer at the audacity of openAI to do something without first asking their permission.