Hey, GitHub, can you create an array compare function without breaking the GPL? GitHub is testing a new feature that will allow developers to instruct its AI-powered programming assistant Copilot to generate code using voice commands. The legally troubled, license-bothering technology isn't a plain speech-to-text dictation engine that would require developers to read out their program source line by line …
Just because somebody has written a function and put the GPL on it, does not mean that it has not been done before. The GPL cannot lay claim to everything. It is also not the only FOSS licence, is it? Suppose GitHub "creates" some AI code based on some BSD code, yet there is something similar in GPL. The GPL does not own tht code.
You really don't understand, do you?
The trouble with Copilot is twofold:
It's completely impossible for a developer to comply with the licences for the code blocks it emits, because they have no idea what the licences are or who owns the copyright.
Copilot itself breaks most licences, because almost every licence requires attribution - BSD included.
The only possible defence would be that none of the blocks it can ever produce are not subject to copyright, which is a very tall order.
It would depend on the amount of code it emits
My phone's auto complete is based on a list of what words most commonly follow other words - that's from analysis of a large number of copyrighted works n English.
If I type "it* and the phone suggests "is" I haven't violated copyright of every author who ever wrote "it is". But if the phone writes " was a dark and stormy night "and I use that in a novel I'm on shakier ground.
In that case, it is the rules of copyright that need to be revised. I understand that copying an entire work is blatant plagiarism, but a 2 or 3 line code block? Come on.
Has anyone ever done a code comparison across thousands of products to find the ratio of similarities in the code? I'll bet there are fucking loads.
We don't want to kill off AI copilots over something as dumb as copyright. I've been using an AI co-pilot for a while now (namely, MutableAI) and they can be invaluable if used correctly.
Let's be honest, we want programming to step out of the shadows and start becoming a tool that anyone can just use...like picking up a hammer. AI copilots are a step in that direction.
"Has anyone ever done a code comparison across thousands of products to find the ratio of similarities in the code?"
I refer you to the Unix copyright cases as launched by SCO. SCO lost not because the code wasn't the same, but because it could be clearly proved that they didn't own the code that was actually contributed to Linux in the first place.
There's a difference, though, between inventing something independently, and using a tool to "generate" it. If you can prove the tool sucked in your code, and then that other code came out at the other end and it's identical... that's not something you can easily defend against.
I suspect this is going to end up costing Micros~1 enough money and bad PR that GitHub ceases to exist (who would trust their confidential corporate data on Azure when the host is known to help themselves without asking?). Whether that was Micros~1's original plan when buying it - well, you might think that, but I couldn't possibly comment.
-> Copilot itself breaks most licences, because almost every licence requires attribution - BSD included.
Tell me, when you copy something off Stackoverflow, do you attribute your copying to them? Or if you copy or modify a piece of code you have seen in a book, do you do the same (despite practically every book having a notice about nothing is allowed to be copied in any way)?
I bet that you don't.
Yes of course, if you don't attribute code how can you hope to remember what you were thinking when someone asks? Why would you not want to add a comment with information -that you already have-? I usually even include 'loosely based on' or 'x does not work because y' so I can recall how I got to some solution, if I'm to the point of searching for code (which, admittedly, I rarely do at this point).
Maybe it's an experience thing?
-> Yes of course
I bet you have a very organised drawer full of underpants.
Literally not a single coder I know who I have seen using a book (such as the Perl Cookbook) has EVER noted down in their code "I got this from such and such a place". Not one. They may mention it verbally. But adding a note in their code? No way. This is about 30 years experience talking. NOT A SINGLE ONE. The same goes for Stackoverflow, which is a supercharged version of the Cookbook-type books.
Hmm, good choice of example, the Perl Cookbook. Assuming you mean the O'Reilly one, you do know that the licence doesn't require any attribution, so in that case those coders are acting completely within the letter of the law:
https://resources.oreilly.com/examples/9780596003135/
The same, or effectively the same, licencing is given at the start of all the other "cookbooks" in my collection (mostly because any cookbook *without* such a clause is a pain to use).
Books with large examples (complete programs and/or libraries) these days expect you to download the material, complete with notices and licences, which therefore ought to be "self attributing" (and if colleagues are failing to commit licences along with source into the repo, or are leaving gaps in the compliance document, well, that is a larger problem).
Having said that, anyone who copies a tricksy bit of cookbook code and doesn't attribute it is an idiot: they'll not understand "their own" code next month. Have you considered getting yourself a better class of colleague?
Your legal team must be either bricking it or have already resigned en masse, if that's genuinely true.
BTW, the book in question has the following in the licence:
We appreciate, but do not require, attribution. An attribution usually includes the title, author, publisher, and ISBN.
If you read the licence, you'd know that.
If you didn't read the licence, you are a fool and sooner or later will cause a rather expensive lawsuit.
I spy, with my little eye, someone who has absolutely no idea what the concepts of "copyright" and "licensing" mean!
Firstly, except for a few outlier cases (unless you want to bring them up), *all* of the source code you are ever going to interact with is copyrighted.
Secondly, *all* licensing *requires* that the material be copyrighted, otherwise there is nothing that *can* be licensed.
Thirdly, (ignoring courtesy, academic requirements and plain common sense) it is the licence provisions that say under what conditions the code can be copied and whether attribution is required.
Unless they state otherwise (because they can put into their books code from other people, so long as they obey the relevant licence - and that code can include code from yet other people, so long as ...) then all the code in the book is (c) O'Reilly. Your use of that code is controlled by their licence, which itself is included inside the book (and is also included, verbatim, in the online provided-for-your-convenience copy which I linked to and which Richard 12 was kind enough to copy from the book as confirmation).
Finally, at the risk of breaking your brain, even if O'Reilly decided to publish a book that contained nothing more than 200 suitable source code examples - and clearly stated which bits were copyrighted by whom - with nothing more than a contents page and a blurb on the back saying "this is a collection of other people's copyrighted source code, used under the terms of the the MIT licence, arranged so that you can learn by working your way through from start to finish" they would STILL clearly mark that book as "Copyright O'Reilly and Associates". And be totally correct in doing so.
Are APIs code? Or simply a description of code? Is it the cake, or the recipe?
Because under most copyright regimes, you can't copyright a recipe. But you can copyright an article. And that's why every time you search for a recipe to make blueberry muffins they start with "In 1912 my paternal great-grandfather was cycling through pre-war Belgium, accompanied only by his faithful Cairn terrier who revelled in the exquisitely inappropriate moniker of Mongoose. And it was while cycling through Ghent, on a foggy Thursday morning, that Mongoose urinated on the drainpipe of a small bakers shop..."
I think you must have been working with some non-professional programmers. (I'll grant you, such are plentiful.) I cannot imagine writing some non-obvious code that came from a place giving a full explanation of it, and then failing to add a few words saying "this is where I got this". I'd just be screwing myself over a few years later when something caused me to have to change that code.
But I do believe you that you could know a lot of coders (more like "code monkeys") who don't do this. I didn't do it at first, as a wet-behind-the-ears programmer at my first job; I had to experience the consequences myself. (I'd done a lot of programming in school, but in that situation, I was the only one who really needed to understand the code and most projects were written and then not revisited. It's not the way things work when you're working with others on a longer-term project.) And one need not look far to find examples of code lacking references to sources (meaning both legal attribution and more practical "look here to read a bit about what this code is doing").
If it's obvious, you wouldn't be copying it from somewhere else in the first place, unless you have absolutely zero programming skills of your own, and everything you produce is some sort of Frankenstein's monster of copy-paste code that "kind of works" under the right conditions.
Actually, I have come across programmers like that, and I've refused to work with them. They haven't lasted, and mention of their names brings shudders to all involved.
Oh, the programmers that don't want to program. They fascinate me.
I'd much rather write code than use someone elses, so I may be a little on the NIH side of things, but I've genuinely had programmers tell me we can't write code because we'd then have to maintain it. (As though importing a library has no consiquences or maintenance requirements).
I don't copy obvious code. For that matter, I don't copy non-obvious code, because that's a recipe for it breaking and having me completely stuck. When I review others' code, I read it to understand how they did what they did. Then I apply the lessons from their solution. Sure, when it's a function call, my line will look like their line, but when it's a wider function, my version will look different from theirs because mine will be tailored to my problem and will omit things I didn't need. My variable names will be explicitly related to what they contain, rather than the shortened form common in examples. My functions will be divided where logical for my use case, not what makes for a clear explanation. I have learned instead of copying and produce a better result for it.
I agree. I've never met anyone that has attributed a dinner they cooked to the chef that wrote the recipe book either. Furthermore, who cares?
I've got a few open source repos on Github that people clone and fork and fuck around with and I don't give a shit if they attribute anything to me. In fact, if their project based on mine sucks (which they usually do), I'd rather they didn't.
> I've never met anyone that has attributed a dinner they cooked to the chef that wrote the recipe book either
Round these parts it is absolutely the norm to tell anyone who asks "Oh, got that from Delia" (or Fanny or Beeton, as appropriate).
Helps with Christmas pressies as well - if they liked the results (and they cook as well, of course) then they'll probably make good use of their own copy of the book. Unless it was the Corner Family Cake recipe - that we keep to ourselves.
Ditto with knitting & crochet patterns, music, circuit diagrams, LEGO models...
Guess it is all just down to the environment you grew up in.
Not to mention I want to explain to people what this weird special case code below my comment actually does, because if I'm going to Stack for answers, it isn't obvious to me, and usually means I'll have to piece together bits and pieces of related ideas to come up with something that works with version x.y of package foo.
Tell me, when you copy something off Stackoverflow...
Quite frankly, if you're copying stuff of Stack Overflow, you are part of the problem.
SO is a useful tool to help you understand a problem, or to identify a standard way of approaching something, for example, how to design something securely, or the steps to go through to call a particularly overcomplicated API where the API owner's documentation is poor (Microsoft I'm looking at you). However, you should use it to learn how to do something, not to copy how someone else approaches something.
Also, if you are taking anything other than something absolutely trivial from somewhere else, you should at the very least put an explanatory comment in your code to say where it has come from, so the poor sap who comes after you can understand what it is they're looking at. That poor sap may even be future you, and future you'll sure as hell thank present-day you for it.
So in summary, copying from Stack Overflow Bad, learning from examples on Stack Overflow Good. Gottit?
Too late. I already did before anyone had heard of Copilot. The problems with copilot are complex and it's pointless trying to say otherwise in either direction.
Everyone has a right to learn from code of all licences that give you permission to view it. Surely that should apply to AI learning too.
Copilot can and does spit out non-trivial copyrighted code with no indication of that it might be copyright. It also learns from code in a completely different way to a human so maybe only human learning should be allowed by these licenses.
Then again the licenses don't specify only human learning. Maybe someone should write one that includes this clause just to make a point?
I think the law has already dealt with AI "creativity", intellectual property and patent issues in some sense. If it doesn't pass through a human, it's not novel.
I can read Github packages for insights into how certain problems have been solved. I can even teach myself how to code. But if that knowledge doesn't pass through a person's mind, it must be attributed to it's source or training dataset.
Strange that Github can't trace its Copilot output back to a source package (where the authorship and license resides). Several AI systems I've worked on provided just such an "explain your reasoning" function. After all, it's just a database and walking through the relational links is just another SQL query. Humans, on the other hand, are always having strange stuff pop into their head. In fact, I suspect that such untracability may be a design feature of some AI.
I don't think that's true for the machine learning methods used by Copilot.
Right. It's not a database (much less a relational one).
That doesn't mean it's necessarily impossible to create an explicable, interpretable, or self-interpreting Transformer model; but I can't offhand think of an approach which wouldn't require a lot more resources. The research I've seen into explicable/interpretable ML is mostly based on other architectures that are more amenable to extracting that sort of information.
That kind of AI system isn't a database.
In general, it's impossible to determine "why" a result appears, only that it does. It's basically a halting problem level of complexity.
The only way to find where an output came from is to take the output and search a database of all the inputs looking for matches.
It can be done. Not practically for a system that trains on a few billion cat pictures and attempts to find cats in some input. But for a restricted training dataset*, when training the neural network, it's possible to save a link to each instance of each training input that results in some change to a 'neuron' weight. And backtrack through deeper layers of the network.
It's a question of whether it's a requirement of the system. And if your AI is providing decisions in a process regulated by some three letter agency and they ask, "What did you base this decision on?" You had better have a list of pilots' trouble reports or whatever it is before you go fiddling with the systems.
*Which arguably GitHub is.
It would be non-trivial to store all those labels on each node as its weighting was changed during the training. And then to sensibly track through what nodes were involved, and how much, in generating this bit of the output, gathering the labels and finally generate some useful results from the whole lot (hey, we can train an ML system to do that).
The real question is, how much extra computation & storage would that require and is it worth it to MS to pay that cost? Given that they could fling those machine resources at building up the main Copilot model.
Or they could take the money needed to pay for that extra processing for X months and buy their way to some legal ruling that says Copilot is totally fine to do what it is doing. And for months X+1, X+2 etc the legal team who managed it get 1/k of the saved costs in their paypacket (k being whatever they can screw out of MS - but those will be expert screwers, so may even end up with 1 > k > 0).
"Copilot can and does spit out non-trivial copyrighted code with no indication of that it might be copyright. "
That's the *only* reason it exists: Drop copyright from copyrighted code claiming your "AI" wrote it by itself. That's the sole reason.
That's the reason why MS bought github in the first place: To *steal everything there is in there* and this is a tool to do so.
No other reasons exist: IP theft in grand scale.
> And stackoverflow specifically has licenses to deal with that.
Which is why you should not copy the code from stackoverflow into commercial code or open source code.
As a source for learning it's great most of the time.
As a copy source its a minefield for lawyers.
It's bad enough having to list every library I link against directly and indirectly along with thier licence for corporate lawyers to trawl over without having to also provide links to every bit of copied code.
Heh.....Copilot.....I've got some triple-enciphered text here....and I'd like some extra encipher code to make sure that the sock puppets at Fort Meade have ABSOLUTELY no way of finding out what I've written. Can you help me out? Of course, I'll need the decipher code as well....so I can send the decipher stuff to my buddies.....Er.h.h.h.h.h..h.h.h..................
====
M1sNwvMf6Do56xUFcdUhSZ65eBm38vgFG5oVsVmP6zSxWHg3ANuPsri5Krk3op43Cb4Vw9Irqd6D
QDqbc7KFARoFSF0N0hC9ormD092Ro7k5qp6bypWR6PmnQvWdURidErgvKt85C7UfqJ6Bybqt6jI5
QVAF8po92JU1uXSfCTwJGjGbyJO9Ofs10zqHU9y3QHOloD2XUFiZUzMP61Q90PSPuJqt2ZGfwBK3
qpC1oDq1KdoBmBWn014NOzQPcnMbA54rS54RmjmfsTmfkTc9c9s1gRQL43oTQXyZGnI3wDOpahkJ
gB0X0TU54RUzmrGhGjyxAzYbq98hY9aDcRUlCZOdQn4FWdmdydSX03212l0lE5m1QPyTijk5W74t
cpq5utKpOTSjEdqV8l0VcRsfOvkfsJEVIdMNGryRibm5Ir6RCF8HKpWHOXctoZoNyv0NgJEvYFoZ
e1MFshsZSb656RsFchgDefEZ4fOv2Lkhq7K56JwtQpYnOVgbCxwjcJwr8xAzMfYdwNQf6LSJg1y7
ClG94hS5KJEPYZaNmhsdgDOzURCpARwBG98FYPu1KN8jKTiHel0biBSRMJk9M7KB8nwzitytsRij
UNapsTGx27kn8jo9yHwlwvcda9cRmb8lSfghynSLUhiN2nkZSlaHEteFgjihO5UpMZyt2Z2ni3WX
Mti3gbYXE1gzsPoTQPUBebmpSvoNobIJcDoFcDAlyzeXYVed8tQ1yVMNIXcvCt212dCLeNu7eLIH
8nM1ePsNyPexm92bmdezmvwvqLihKXa98jUZmX0BOBSbsxMXOFQn07yFURQjarOPo1kt41kbQDU1
2Ro90DERSLinyVALyrcVCfOXuFCzmP8ToNaXoxAtgjEP6r4jWnAVeTEpufWlctaXULoZ4zcTWv0l
Qj0t4zEVSPgzEhg1c7mbal4Lo5el2PWLktAJQNQTaTWJiFOti9GrepynatQvGjyHShSjSZs1a78r
w3wt8PsXoZ2R0Zs30nCT8P430va7edqJoXwRUPK9I5C7YDgrWpGHqDcHCVKDYv834F2HyDSB6lsd
CnGl0X8JQVEXcbYxQtAbqT0lGloHsX8LojKp2fGDijO7SNYbCJajcJirQrWhYjU3w1oZWnE3gvCT
iJy3aDMrqPkp8HQxyNuHOh4J2TGNqxE7aXAnGnSfqp0PMneb4dGdQNM1MJ6Vu7ODCpWxiVCRgZUl
srCTwns9EnMZOZM9MZkleXor4h8huly5m1M3KNalOFmLo3QNOnC18PWNwh63WdenmxefqVoDyBSJ
Gd0xsVWty1o3yXwn
====
OzURCpARwBGEnGlaNdT20SuCceSs98FYPu1KN8jKTiHel0biBSRMJk9M7KB8nwzitytsRij
UNapsTGx27kn8jo9yHwlwvcda9cMarCZuCkerBurg1sADiCkHeAdRmb8lSfghynSLUhiN2nkZSlaHEteFgjihO5UpMZyt2Z2ni3WX
Mti3gbYXE1gzsPoTQPUBebmpSvoNobIJcDoFcDAlyzeXYVed8tQ1yVMNIXcvCt212dCLeNu7eLIH
8nM1ePsiMaTra1nsP0tTerNyPexm92bmdezmvwvqLihKXa98jUZmX
Can you cope with me choosing my own wake word phrase for you? You seem to have an enormous amount of computing power and storage so this should be a really simple function to implement.
I'm not an American college kid and don't actually know ANYONE who starts a greeting with "Hey! $name". In my culture that's both rude and childish.
Do I understand it correctly that some programmers are writing code so that programmers become largely irrelevant ? Apart from the prospect that it will never work, why do people commit such community suicide ? Do they think that, by making other programmers irrelevant, somehow they will escape that fate ?
And I'd be very curious to see a bot writing software that I do.
Well, as it's not actually going to make programmers irrelevant, there's not much risk in it for them. But yes, people do that. Programmers have written lots of things over the decades to make their job easier, which in turn means you need fewer programmer-hours (less time, which means one programmer can do more tasks). That's a good thing for the people who use programs and indeed for programmers themselves. If we hadn't done that, the availability of usable personal computers would have been significantly slowed, meaning fewer jobs as there would be much less demand for software.
We don't strive to create artificial antiquity just to make things easy; we prefer quality and efficiency. I've seen arguments for not updating inefficient processes because the people who do them would need to learn to do something else, and such arguments are usually unfounded and futile (even when it's tried, it doesn't work out for long).
"It's hoped that coders will be able to say out loud things like general descriptions of functions, and have Microsoft-owned Copilot recommend the source to fulfill that request."
Part of me thinks any "coders" who use this should probably just buy pre-existing software, or figure out how to do it in Excel.
If we take the "programming" out of Programming, what's left? I mean, that sounds suspiciously like "Management", not coding.
Creating images based on text means an unambiguous understanding of the text when all its words are understood only in one and the right sense. What can be done only by comparing the text in question with those texts whose words have already acquired an unambiguous interpretation.
This can go wrong.
"a new feature that will allow developers to instruct its AI-powered programming assistant Copilot to generate code using voice commands"
The greatest challenge (and it's huge) for those creating computer languages has always been avoiding the ambiguity inherent in human languages. So now we start again from square one?
It's worthy of note that, whilst I work in a software company, none of my developer peers have an "Alexa" or similar. All the marketing types do, of course, because they are the type who think that voice control is "cool" and fail to realise that it is 99.9% a gimmick (and, more importantly, from a security perspective, an attack surface). Granted, there are cases where it is useful, for example, for disabled users. If only we could find a way to "disable" salespeople, eh?
The Register 
Biting the hand that feeds IT
Copyright. All rights reserved © 1998–2025
