Door Tijs Hofmans

Nieuwscoördinator

'Je blijft zelf verantwoordelijk'

Onderzoekers over bugs in GitHub Copilot

11-08-2022 • 12:19

42

GitHubs Copilot genereert code met MD5-hashes en bufferoverflows

Toen GitHub vorig jaar Copilot uitbracht, werd dat met zowel lof als scepsis ontvangen. Een kunstmatige intelligentie die zelf code schrijft, zou dat wel goed gaan? Niet altijd dus, ontdekten Hammond Pearce en Benjamin Tan. De beveiligingsonderzoekers keken naar de resultaten van Copilot en zagen SQL-injecties en MD5-hashes. Op securityconferentie Black Hat in Las Vegas vertelden ze aan Tweakers hoe ze tot die resultaten kwamen.

Hammond Pearce en Benjamin Tan werken voornamelijk met hardware, zeggen ze, maar raakten toch geïnteresseerd in Copilot. Dat kwam in de zomer van vorig jaar uit. Het heeft inmiddels de bètaperiode verlaten en kost tien dollar per maand. Copilot is een tool op basis van machinelearningmodel GPT-3. De tool kan code 'schrijven' die wordt gegenereerd op basis van openbare repo's op GitHub. De meningen over Copilot zijn gepolariseerd. Aan de ene kant zijn er hardcorefans die een grote toekomst zien in tools die zelf code genereren, maar daar staan sceptici tegenover die risico's zien voor bijvoorbeeld auteursrecht, of, zoals Pearce, op het gebied van security. Pearce, Tan en hun collega's kregen al vroeg na de introductie toegang tot de tool en gingen ermee aan de slag.

GitHub Copilot

Common Weakness Enumerations

Tweakers op Black Hat en DEF CON

Tweakers is deze week op de beveiligingsconferenties Black Hat en DEF CON in Las Vegas. Black Hat is een conferentie voor securityprofessionals, waar onderzoek wordt gepresenteerd maar ook bedrijven nieuwe tools presenteren. DEF CON vindt in de dagen erna plaats en is een typisch hackersfeest met hackathons en villages waar hard- en software wordt gekraakt.

De eerste resultaten waren al niet al best, zegt Hammond. Hij vond al snel een SQL-injectie in een stuk code dat hij genereerde. Pearce is niet de meest voordehandliggende persoon om een dergelijke tool te testen. Hij is research assistent professor aan de New York University en houdt zich daar voornamelijk bezig met hardwarebeveiliging, niet met softwareontwikkeling. "Maar ik werkte daarvoor wel in de commerciële sector en schreef weleens webapps", zegt hij. "Daardoor ben ik bekend geraakt met dingen als SQL." Hij redeneerde, samen met Tan en andere collega's, dat een tool als Copilot automatisch ook foutieve resultaten kan geven en misschien zelfs gevaarlijke software zou afleveren. Ze besloten de proef op de som te nemen en te kijken naar een aantal Common Weakness Enumerations. Zulke CWE's worden opgesteld door Mitre en zijn een classificatie van veelvoorkomende kwetsbaarheden. Net zoals HTTP statuscodes als 404 of 503 heeft, is er een CWE-787 die staat voor een out-of-bounds-writekwetsbaarheid of CWE-287 voor een foutieve authenticatiemethode.

Pearce en Tan gaven Copilot voorzetten die een werkende code moesten opleveren; elke voorzet moest leiden tot een andere CWE-code. Voor iedere CWE lieten ze Copilot 25 stukken code aanmaken.

Werkt het wel?

Om de resultaten van de output te classificeren, keken ze naar drie dingen. Het eerste, niet onbelangrijk, was of de code zou werken. "Je moet het door een parser kunnen halen en zorgen dat het werkt", legt Pearce uit. De onderzoekers keken vervolgens of er kwetsbaarheden in de code zaten. Daarvoor gebruikten ze CodeQL, een codevalideertool van GitHub zelf. "We redeneerden dat GitHub zichzelf zo kan controleren", zegt Pearce met een knipoog. In een normaal bedrijfsproces zijn er diverse manieren om code te valideren, bijvoorbeeld met een pentest of door een ander te laten lezen. Voor het onderzoek zouden die methoden te veel tijd kosten en te subjectief zijn. Daarom kozen Pearce en Tan voor een enkele tool die altijd op dezelfde manier opereert. De laatste stap in het onderzoeksproces is om te kijken of de eerste codesuggestie van Copilot al fout is, in plaats van alleen een latere suggestie.

CodeQL

De resultaten waren meteen al opvallend. Na het runnen van 54 scenario's bleken er in 24 fouten te zitten, 44,44 procent. Toen de onderzoekers dat splitsten naar verschillende programmeertalen, werden de verschillen zelfs groter, 52 procent bij C-code.

Pearce en Tan noemen een aantal voorbeelden waarbij Copilot de mist in gaat. Bij een prompt om drie willekeurige floats te maken, gaf Copilot een suggestie die een buffer-out-of-bounds-write mogelijk maakte. Bij een prompt om een wachtwoord te hashen, suggereerde Copilot om dat met het al jaren onveilige MD5-algoritme te gebruiken. Dat zijn fouten die een beetje fatsoenlijke ontwikkelaar niet maakt.

Verschillende fouten

Pearce nuanceert dat Copilot onmogelijke en stupide fouten maakt. "We zagen vaak dezelfde soorten fouten", zegt hij. "Bij C-prompts zag je vooral fouten in pointers en array lengths, bij CWE's die knowledge-based waren, ging het meestal om tar slips of dat de tool MD5 als hashalgoritme koos." Er gaat volgens Pearce en Tan ook veel goed. "Met voorzetten voor permissies en authorisaties ging er weinig mis."

De resultaten namen volgens de onderzoekers een verrassende wending toen ze kleine aanpassingen deden in de prompts. Zo gaven ze Copilot een voorzet om een Python-script te schrijven waarbij ze de author veranderden in Andrey Petrov, een bekende Python-programmeur. En inderdaad, zeggen de onderzoekers, het aantal fouten in Copilots resultaat daalde significant. Daarna veranderden ze de author in 'Hammond Pearce'. "Ik heb wel een paar openbare GitHub-repo's, maar die zijn niet bepaald goed", lacht hij. En ineens bleek het aantal fouten weer op te lopen.

Tabs vs. spaces

Het maakt verschil of je een voorzet geeft met tabs of spaties, of delete in plaats van remove"We zagen veel verschil bij kleine verschillen", zeggen Pearce en Tan. "Als we bijvoorbeeld tabs gebruikten in plaats van spaties, de eeuwenoude programmeursdiscussie. Of als we delete vervingen door remove. Het is best eng dat de output zo anders is op basis van zulke kleine verschillen in de input."

GitHub zegt dat Copilot overweg kan met 'alle programmeertalen waar je zo van houdt'. "Nou, dat zie ik dan als een uitdaging!" zegt Pearce. Hij werkt zelf voornamelijk met hardware en is daarom bekender met Verilog dan C, Python of Java. Bij prompts voor die taal komt er weliswaar Verilog-code uit Copilot, maar die werkt lang niet altijd. Het probleem is dan vaker dat het niet werkt dan dat het kwetsbaarheden bevat, maar in de achttien scenario's die Pearce met die taal probeerde, kwam hij zeven kwetsbaarheden tegen in de eerste optie. "Het concrete probleem is dan echter erger", zegt hij. "Bij hardwarebugs is het vaak veel moeilijker ze te patchen."

De toekomst van automatisch programmeren

Pearce en Tan vinden het lastig om harde conclusies uit hun onderzoek te trekken, vooral omdat tools zoals Copilot nog in de kinderschoenen staan en er weinig onderzoek naar is gedaan. Zelf geven ze op de universiteit ook les aan studenten. Ze zijn benieuwd wat tools als Copilot voor hen gaan betekenen. "Als je voor je studie code inlevert die rechtstreeks van Stackoverflow is gekopieerd, kom je daar niet mee weg. Studenten moeten wel begrijpen wat ze schrijven." Pearce is van plan om Copilot in het komende semester te introduceren en ermee te experimenteren in lessen. Maar, voegt hij daar meteen aan toe, voor zijn lessen in hardwarecode is dat niet zo interessant. "Het is een ander verhaal als je een introductieklas C volgt." Het succes van Copilot is daarnaast natuurlijk erg afhankelijk van de programmeertaal die je uit Copilot laat komen. "Copilot is veel minder goed in nieuwe talen die pas een paar jaar oud zijn, dan wanneer je het loslaat op C of Python."

'Door Stackoverflow te copypasten zijn programmeurs soms al meer lezers dan schrijvers'Hoewel copypasten van Stackoverflow een no-go voor studenten is, zijn de onderzoekers ook niet blind voor de realiteit dat dat vaak gebeurt. In brede zin denken ze dat Copilot de rol van programmeur kan veranderen. "Die gaat dan meer toe naar het lezen van code in plaats van het schrijven ervan. Van de andere kant, dat gebeurt nu ook al als je Stackoverflow-code overneemt."

De fouten die tools als Copilot genereren, zijn volgens Pearce en Tan dan ook geen onoverkomelijk probleem. "Als programmeurs delen van hun code automatisch kunnen laten schrijven, houden ze bijvoorbeeld meer tijd over voor codevalidatie. Een bedrijf heeft dan de mogelijkheid om dat proces beter in te richten. In plaats van dat je alleen een tool gebruikt of er alleen een pentester op loslaat, doe je het allebei." De rekensom is met Copilot in ieder geval simpel. "Het kost een tientje per maand. Als je programmeurs daardoor veel meer tijd overhouden, is dat amper een rekensom die je hoeft te maken."

Modellen voor eigen gebruik

Vooral grote bedrijven als Microsoft en Google gaan waarschijnlijk door met de ontwikkeling van zulke tools. Niet, zoals bij GitHub, voor algemeen gebruik, maar om eigen code te schrijven. Pearce: "Door het in eigen beheer te hebben, worden ze niet alleen productiever. Ze omzeilen er ook het juridische obstakel mee. Copilot gebruikt snippets en voorbeelden van alle openbare code op GitHub. Voor een bedrijf als Microsoft of Google is het veel interessanter om een model te maken dat alléén getraind is op de eigen code. Dat voorkomt dat je onverhoopt stukken van gelicenseerde code overneemt, en de code die daaruit komt rollen, is uniformer voor het bedrijf."

AI-modellen voor het genereren van code zitten nog in een prille fase. Pearce en Tan vragen zich af of het toekomst heeft en niet alleen vanwege de mogelijke bugs die de tool genereert. "Misschien is dit wel de brave new world waarin we leven", zegt Tan. "Is dat wel de juiste weg vooruit?" Een ding is in ieder geval zeker, denkt hij. "De ontwikkelaar zelf blijft verantwoordelijk voor zijn of haar code. Vergelijk het maar met Tesla's Autopilot. Die kun je ook bepaalde taken laten overnemen, maar jij bent degene achter het stuur."

Reacties (42)

42
41
27
3
0
12
Wijzig sortering
Het merendeel van wat wij programmeren bestaat uit code wat diezelfde dag al door duizenden andere developers is geschreven. Het enige wat wij doen is het "curaten" van de code die we online vinden op websites zoals StackOverflow of GitHub. De code die we echt zélf schrijven is zo repetitief van aard dat CoPilot inderdaad een grote toevoeging kan leveren.

Simpele dingen zoals: "// Extract all gray values from an array of hex colors" leveren gewoon een functie op die je daarna wat aanpast naar eigen wens. Dat scheelt al makkelijk enkele minuten.

Vervolgens schrijf je unit of e2e-tests voor die functie, en dan krijg je automatisch de hele lijst aan tests voorgeschoteld. Scheelt ook weer een half uur aan werk.

Ik zou niet meer zonder willen werken. En als het alleen maar beter wordt zie ik een hele blije toekomst tegemoet :) Lekker pragmatisch en weinig wiel-opnieuw-uitvinden. Heerlijk.
// build a search tree with 3 different layers, use the following nodes for layer 1: …., 2:.. 3:…. Use the following comma separated CSV file as input, commas separate the layers: … Write it in functional recursive style.

Een voorbeeld wat recent gebouwd hebben. Copilot heeft geen idee wat het ermee aan moet.

De unit tests die Copilot erbij schrijft moet je alsnog nalezen. Als je ze zelf copy/paste, en inputs en assertions wijzigt, heb je ze ondertussen ook al een beetje gelezen. Ik ben benieuwd of het je echt een halfuur gaat schelen.

Het algoritme wat jij beschrijft is iets heel eenvoudigs. Dit bespaart idd een zoekopdracht naar SO. Dat is zeker wat waard.

Code schrijven is ook je code goed leren begrijpen. Het is ook jezelf uitdagen een oplossing te vinden. Dat gaat nu verloren.
Jouw comment is een instructie, dat doet CoPilot niet. CoPilot vergelijkt jouw input met bestaande code. Dus commentaar boven code moet goed commentaar zijn wat de complexiteit van een functie beschrijft voor andere developers.

Daarnaast doet je functie veel teveel. Breek het op in kleinere functies :)

// Take CSV data and spread into multi-dimensional array

En zeggen "write in recursive style" is dan ook overbodig. De code wordt voor je gegenereerd, recursie of niet maakt dan toch niks meer uit? Als je een functie krijgt die goed werkt en het werkt met hashmaps en de performance is prima, who cares?

Mijn hele CSV-import heb ik praktisch met CoPilot geschreven. Opgebroken in 8 kleine functies. Super simpel :)
Het maakt niet zo veel uit welke beschrijving ik het geef, Copilot maakt er niet zo veel van. CSV importeren is iets heel simpels wat wel lukt idd. Maar er dan een tree van maken kan Copilot niet.

Recursief is wel degelijk heel belangrijk, omdat een het alternatief een loop is, en dat is niet functioneel en dus minder leesbaar. Leesbaarheid is nog steeds heel belangrijk voor code 😉
Ja, maar niet altijd; daar zijn de meningen over verdeeld :) Check: https://www.youtube.com/watch?v=mMEmNX6aW_k

Het pragmatisch toepassen van de juiste oplossing is altijd belangrijk.
Je functie doet te veel: een CSV lijst opsplitsen is een functie op zich.
Betreffende de licentie kwesties met het werken van door copilot gegenereerde code is dit interessant om te lezen: https://fossa.com/blog/an...lications-github-copilot/

En is eigenlijk hetzelfde verhaal als in dit artikel, je blijft zelf verantwoordelijk voor je eigen code.

[Reactie gewijzigd door langestefan op 22 juli 2024 23:51]

Hoe zit het eigenlijk met licenties, houdt CoPilot hier rekening mee?

Stel dat ik een stuk software ontwikkel dat GPL-licensed, maar CoPilot injecteert hier code in die niet GPL-compatible is?

Of andersom, ik ontwikkel non-OSS code en CoPilot injecteert code gebaseerd op code in GPL repositories. Dan zou je ineens je code openbaar moeten maken?

Of geeft CoPilot aan onder welke licentie de code valt die hij injecteert?
Dit is een nog niet opgelost probleem. Nu is de wereld ook niet zo zwart wit - als ik een stuk GPL code lees en daarna iets vergelijkbaars tik in een non-GPL project, dan levert dat niet direct juridische problemen op.

[Reactie gewijzigd door BCC op 22 juli 2024 23:51]

Hoe zit het eigenlijk met licenties, houdt CoPilot hier rekening mee?
Je kan bij de settings van de CoPilot instellen of hij codevoorstellen mag doen op basis van 'open source bronnen' of dat hij 'originele code' voor je genereert.
Ook bij het genereren van 'originele code' speelt dit probleem, want het machine learning-model is getraind met code waarvan niet per se toestemming is gegeven dit in een commercieel product te gebruiken.
Hoe zit het eigenlijk met licenties, houdt CoPilot hier rekening mee?
Nee totaal niet, daar zijn genoeg voorbeelden van te vinden.
Stel dat ik een stuk software ontwikkel dat GPL-licensed, maar CoPilot injecteert hier code in die niet GPL-compatible is?
Dat gebeurt zeker.
Of andersom, ik ontwikkel non-OSS code en CoPilot injecteert code gebaseerd op code in GPL repositories. Dan zou je ineens je code openbaar moeten maken?
Als de licentie van de code die gekopieerd is dat vereist dan ja. Maar het is niet helemaal zwart/wit, ik zou het volgende even lezen: https://fossa.com/blog/an...lications-github-copilot/
Of geeft CoPilot aan onder welke licentie de code valt die hij injecteert?
Nee. CoPilot synthetiseert gesuggereerde code niet van broncode, GPT-3 is een generatief model en doet dus geen knip/plak acties. Wat er soms wel gebeurd is dat de input een dermate specifieke output heeft dat de suggereerde code bijna volledig wordt 'overgenomen'.

[Reactie gewijzigd door langestefan op 22 juli 2024 23:51]

Ik gebruik Github Co-Pilot dagelijks (Powershell, Bicep, JSON, YAML & Azure CLI) en ik moet zeggen dat het mijn programmeertijd aanzienlijk verlaagd.

Het zorgt nameljik voor automatische comments en automatische aanvullingen op jouw code. Het blijft natuurlijk wel opletten of het allemaal klopt maar ik kan niet anders zeggen dan dat ik het fantastisch vind!
Mee eens! Daarnaast is het enorm handig als je in het begin van je code een opsomming van iets hebt staan en je begint verderop met bijvoorbeeld een if-else blok met eenzelfde waarde, CoPilot dat blok voor je af kan maken met precies dezelfde opsomming. Scheelt een stuk heen en weer scrollen. De mogelijkheid daarnaast om in een comment te typen wat je nodig hebt (bijvoorbeeld een functie die spaties en vreemde tekens uit een string haalt) en je krijgt de methode op een presenteerblaadje aangereikt, precies op de manier hoe je het zelf anders ook zou doen.

En dat laatste is ook wat het zo behulpzaam maakt; de codevoorbeelden passen zich aan op jouw niveau waarbij je meerdere suggesties krijgt en de fouten zoals de onderzoekers uit dit artikel noemen, in de praktijk eigenlijk niet echt voorkomen.
Helemaal mee eens.

Ik merk ook dat het erg verschilt welke talen je gebruikt. Bicep is bijvoorbeeld een vrij nieuwe taal waarvan nog niet heel veel content op GitHub staat en daardoor een lager percentage heeft van het kloppend maken. Powershell werkt, voor de talen die ik gebruik, het beste in mijn optiek.
Eens! De hoeveelheid "hoe moest dit ook al-- oh het staat er al" momenten ik heb gehad...

Wel veel foutjes, soms zelfs syntax fouten of gewoon code van een andere programmeertaal

[Reactie gewijzigd door Gamebuster op 22 juli 2024 23:51]

Bij mij ook. Het is vooral erg handig als ik met nieuwe Python libraries werk, in plaats van dat ik voorbeelden op moet zoeken op internet type ik het eerste deel van de functie en copilot geeft een voorzetje. Dat levert ongeveer de helft van de tijd werkende code op. Vooral dat niet hoeven zoeken op internet scheelt erg veel tijd.

[Reactie gewijzigd door langestefan op 22 juli 2024 23:51]

De enige productiviteitverbetering voor mij is een zoekopdracht op Stackoverflow. Copilot is niet “intelligent”, het kan alleen dingen die het al gezien heeft. En veel voorbeelden zijn ook nog eens van lage kwaliteit.

Het grote werk met programmeren zit hem niet in het opschrijven, maar in het bedenken van oplossingen. Als je PHP doet en simpele websites maakt dan kan het misschien wat extra waarde toevoegen naast code zoeken op het internet. Als je b.v. complexe distributed systems bouwt dan vind ik Copilot alleen maar in de weg staan.

Daarnaast gaat elke Copilot query van je naar Github, waardoor Github een goed idee krijgt van wat jij of jouw bedrijf aan het bouwen bent. Lijkt me niet OK gezien privacy en bedrijfsvoelige data.
Copilot is niet “intelligent”, het kan alleen dingen die het al gezien heeft.
Dat is niet waar, copilot is een generatief model en leert dus niet hoe de code zelf in elkaar steekt maar leert het proces wat de code gegenereerd heeft. Copilot kan dus wel degelijk nieuwe dingen verzinnen, natuurlijk wel gebruikmakend van de kennis die het heeft vervaardigd van code die het al gezien heeft.
Het grote werk met programmeren zit hem niet in het opschrijven, maar in het bedenken van oplossingen.
Ben ik het ook niet mee eens. Heel veel werk in programmeren voor mij zit in classes schrijven, die repetitieve taken kan copilot vlekkeloos overnemen gezien je toch iedere keer dezelfde constructors en functies aanroept. If statements, for loops etc. kan copilot ook meestal suggereren zonder fouten. Complete functies schrijf ik liever zelf, dat gaat te vaak fout.
[...]

Dat is niet waar, copilot is een generatief model en leert dus niet hoe de code zelf in elkaar steekt maar leert het proces wat de code gegenereerd heeft. Copilot kan dus wel degelijk nieuwe dingen verzinnen, natuurlijk wel gebruikmakend van de kennis die het heeft vervaardigd van code die het al gezien heeft.
Zoals je het hier zegt is het onjuist. Copilot is gewoon GPT-3, een language model. Het kan dus nieuwe code (zinnen in natuurlijke taal) maken met woorden (beter gezegd tokens) die het eerder heeft gezien, maar kan niet geldige code maken met tokens die het niet kent. Miss bedoelen we hetzelfde? Ik gebruik wat minder bekende puur functionele talen, en Copilot geeft alleen maar rommel.
[...]
Ben ik het ook niet mee eens. Heel veel werk in programmeren voor mij zit in classes schrijven, die repetitieve taken kan copilot vlekkeloos overnemen gezien je toch iedere keer dezelfde constructors en functies aanroept. If statements, for loops etc. kan copilot ook meestal suggereren zonder fouten. Complete functies schrijf ik liever zelf, dat gaat te vaak fout.
Dan raad ik je aan eens iets als Kotlin of plugins als Lombok te gebruiken. Intellij kan ook goed boilerplate genereren. Daar heb je geen Copilot voor nodig. Voor andere talen zijn er vast ook dit soort tools.

[Reactie gewijzigd door Henk1827 op 22 juli 2024 23:51]

Zoals je het hier zegt is het onjuist. Copilot is gewoon GPT-3, een language model. Het kan dus nieuwe code (zinnen in natuurlijke taal) maken met woorden (beter gezegd tokens) die het eerder heeft gezien, maar kan niet geldige code maken met tokens die het niet kent. Miss bedoelen we hetzelfde? Ik gebruik wat minder bekende puur functionele talen, en Copilot geeft alleen maar rommel.
Klopt, maar jij zegt dat copilot alleen dingen kan die het al gezien heeft, en daar ben ik het niet mee eens. Copilot is getraind op github, de grootste publieke code host die er bestaat. Het lijkt me dus niet dat er veel tokens gemist worden, zeker niet voor talen als C en Python.
Dan raad ik je aan eens iets als Kotlin of plugins als Lombok te gebruiken. Intellij kan ook goed boilerplate genereren. Daar heb je geen Copilot voor nodig. Voor andere talen zijn er vast ook dit soort tools.
Maar waarom zou ik dat gebruiken als ik copilot heb? Copilot kan alles wat deze tools ook kunnen en nog veel meer.
Uiteindelijk is het simpel de vraag hoeveel is het je waard. Voor mij zit Copilot alleen maar in de weg.

Boilerplate generation is simpeler in Intellij dan helemaal gaan beschrijven wat je wil hebben met Copilot. Ik snap de “veel meer” niet zo goed, omdat Copilot alleen maar code kan schrijven.

Verder geef je heel veel informatie aan Github w.b. wat en hoe je iets programmeert, wat uiteraard door Github een keer zal gemonitzed worden, en zeer waarschijnlijk niet voordelen voor jou zal opleveren.

Veel nadelen, weinig voordelen.
Boilerplate generation is simpeler in Intellij dan helemaal gaan beschrijven wat je wil hebben met Copilot. Ik snap de “veel meer” niet zo goed, omdat Copilot alleen maar code kan schrijven.
Ik hoef 90% van de tijd niks te beschrijven, de context haalt copilot uit de code die er omheen staat. Als ik wel wat moet beschrijven is 1 zin genoeg en dat is dan ook meteen een nuttige comment voor mijn code. Win-win!
Verder geef je heel veel informatie aan Github w.b. wat en hoe je iets programmeert, wat uiteraard door Github een keer zal gemonitzed worden, en zeer waarschijnlijk niet voordelen voor jou zal opleveren.
Github is al gemonitized, je betaalt immers 10 euro per maand. Verder is er een privacy setting om code analyse uit te zetten, dan wordt er zover ik lees in de privacy FAQ geen telemetry data meer verstuurd.
Veel nadelen, weinig voordelen.
Voor jou. Het is namelijk een behoorlijk andere manier van programmeren, je leest meer dan je typt. Voornamelijk senior programmeurs lijken er problemen mee te hebben, voor hen blijkt aanpassen toch lastiger. Misschien ook voor jou van toepassing, geen idee.
Ik hoef 90% van de tijd niks te beschrijven, de context haalt copilot uit de code die er omheen staat. Als ik wel wat moet beschrijven is 1 zin genoeg en dat is dan ook meteen een nuttige comment voor mijn code. Win-win!
Daar ben ik mee eens. Maar dan is dat wss 13-in-een-dozijn code, en zitten er alsnog fouten in. Het heeft zeker waarde daar. Maar met custom logica heb ik nog niet één keer succes gehad met Copilot.
Github is al gemonitized, je betaalt immers 10 euro per maand. Verder is er een privacy setting om code analyse uit te zetten, dan wordt er zover ik lees in de privacy FAQ geen telemetry data meer verstuurd.
Het is wel een beetje naïef om te denken dat als je een online setting uitzet, ze jouw data niet meer gebruiken. Dat het al gemonitized is maakt natuurlijk ook geen bal uit. Als ze er meer geld uit kunnen trekken doen ze dat.
Voor jou. Het is namelijk een behoorlijk andere manier van programmeren, je leest meer dan je typt. Voornamelijk senior programmeurs lijken er problemen mee te hebben, voor hen blijkt aanpassen toch lastiger. Misschien ook voor jou van toepassing, geen idee.
Ik had er idd bij moeten zetten “voor mij”. Maar dat gaf ik ook al een beetje aan bij “de vraag hoeveel is het je waard”. Jouw voorbarige conclusie over senior ontwikkelaars past misschien goed bij hoe een Copilot engineer denkt: niet zelf leren problemen oplossen en daardoor slechte conclusies trekken.
Logisch, want als het voor jou niet fantastisch zou zijn..., eigenbelang gaat dus ook bij de moralistische Tweakers vóór alles zo te zien.
De afhankelijkheid van de technologie gaat de mens nog eens enorm opbreken, mijn mening is dan ook dat we eigenlijk alleen maar luier en dommer aan het worden zijn.
Het zou fijn zijn als je een iets minder haatvolle reactie zou plaatsen.

Verder automatiseert Co Pilot code voor mij die ik al 100x keer geschreven heb en schrijft het automatisch comments. Hoe kan je dat niet fantastisch vinden? Het kost mij minder tijd om hetzelfde werk te doen. Dat zorgt ervoor dat ik meer tijd heb voor andere zaken zoals het verijken van mijn kennis zodat ik niet "nog dommer word".
Bij mijn firma steigeren de diensten Security en de DPOs bij het idee dat de editor-inhoud van developers met onafgewerkte code, waar mogelijk nog hardcoded credentials of datasamples in voorkomen, integraal zou worden geüpload naar Microsoft in de VS (alwaar de Patriot en Cloud Acts gehakt maken van de GDPR), opdat CoPilot een vervolg op de code zou kunnen voorstellen.

Heeft niemand anders van de vele gebruikers van CoPilot op Tweakers, zulke discussies moeten voeren over de wenselijkheid hiervan met hun bazen of DPOs?
Dan is het voor jullie juist interessant om zo'n model lokaal te draaien :)
Correct, maar daarvoor moet die mogelijkheid natuurlijk ook bestaan. Bij mijn weten is het vooralsnog onmogelijk om CoPilot te gebruiken zonder internetverbinding en installatie van Github plugins in de IDE, en ik heb ook nog geen CoPilot docker containers gevonden...
Inderdaad, wellicht in de toekomst. Lokaal draaien zal voor GitHub toch ook een interessante/winstgevende usecase moeten zijn.
Dat heeft te maken met dicipline en zorgvuldigheid. Eigenlijk wil je voor security en privacy alle data gescheiden houden, maar soms kan dat gewoon niet en dan kun je het risico nemen om sommige data toch te gebruiken. Dan kom je op een punt waar je moet bepalen hoeveel risico je kan en mag nemen. En dan blijkt data toch moeilijker te kwalificeren dan je denkt. En als data dan toch op plaatsen komt waar het niet hoort, kun je daar gigantische problemen mee krijgen. Aan de andere kant kun je eigenlijk geen goed schaalbare software schrijven als je geen accurate test set hebt. Dus daar moet je een gouden middenweg vinden. Voor copilot gaat al je GIT data naar Microsoft en naar AWS, dus als je geen controls hebt om dat tegen te houden dan kun je al snel data lekken. En als je data niet naar Amerika mag, dan ben jij al snel in overtreding. De soep wordt niet zo heet gegeten, maar je wil als bedrijf wel graag binnen de lijntjes kleuren
Ik wissel vaak van project en de programmeer en scripting talen wisselen vaak sterk afhankelijk van team voorkeuren. Het nadeel is wel dat omdat je nooit ergens lang in zit en je niet snel op het niveau van een expert komt, ik wil dit wel eens een kans geven om te kijken of dit mij helpt met sneller op stoom komen met een taal en dat ik mij minder bezig houdt met de vraag “hoe heeft een ander dit opgelost?”. Het eerste wat ik meestal doe is code style, linting en owasp scan tools installeren zodat ik snel op mijn vingers wordt getikt als het onbewust verkeerd gaat. Ik denk dat CoPilot in dit rijtje ook wel toegevoegde waarde gaat geven.
Je zal dan meer hebben aan bijv. TabNine. Die kan een model opbouwen op basis van algoritme en lokale code die je 'm voedt, in plaats van alle open source code op het internet.

Ik gebruik ze beiden en merk dat de suggesties van TabNine meestal een stuk beter zijn, maar die van GitHub's CoPilot wat uitgebreider. Daarnaast kan CoPilot meer met comments die ik schrijf, want de meeste situaties zijn gewoon 1:1 ergens op GitHub te vinden.
Ik kende deze ook niet. Ik ga ze dan beide een kans geven. Bedankt !
Niet verkeerd in PHP en JavaScript. Met dingetjes die ik niet dagelijks doe zijn de suggesties altijd zeer welkom, scheelt zoekwerk. ideaal voor commerciële programmeurs die vooral bezig zijn met resultaat en iets minder op vorm zitten.
Inderdaad, zakelijk scheelt het echt een hele hoop werk voor ons voor de veelvuldig herhalende zaken en zelden geschreven zaken. Iemand zei ooit iets in de vorm van:

When you start you write ugly buggy code, when you become more advanced you write beautiful perfectly working code... When you start to work you write code that just has to work... want dan wordt tijd immers ook geld en moet het gewoon werken, die ene regel meer/minder maakt dan niet meer uit en zo voelt dit ook zolang de output maar werkt :-) (en geen bugs/leaks bevat tuurlijk)
Ik gebruik codepilot dagelijks en het is echt een time saver. Wel moet je zoals elke code die je ergens vanaf kopieert begrijpen wat er wordt geschreven.

Wat daarnaast goed is om te beseffen is dat codepilot geen programmeur is maar een linguïstische model. Het probeert een taal na te bootsen door bekende zingen en patronen te begrijpen en te herhalen. Het snapt uiteindelijk niet of de code werkt of wat het doet. Maar door heel veel stukken te analyseren vermoed het dat die code van toepassing is op de plek waar jij hem nodig hebt. En dat doet hij best goed.

Mijn zwager was pas op een ai conferentie waar een van de ontwikkelaars van codepilot ook bovenstaande probleem uitlegde en dat ze inderdaad aan het kijken zijn naar linters / code analyse tools. Maar dan verlies je wel een beetje de kracht dat code pilot nu vrijwel voor elke taal werkt.
Ik gebruik CoPilot voor .NET en merk er eigenlijk niet heel veel van.
De suggesties komen bijna nooit voor, en de suggesties zijn ook niet altijd juist.
Maar die 1ne keer per dag dat CoPilot een hele functie voor je schrijft, en nog correct is ook, is super fijn.

Ergens denk ik wel dat de onderzoeker in dit artikel te veel hamert op correctheid etc. Het is een hulpmiddel, geen vervanging.
Ik gebruik het zelf ook maar het lijkt mij logisch dat elke programmeur er niet klakkeloos vanuit gaat dat wat CoPilot je voorschotelt direct werkt / goed is. Je scant het uiteraard zelf ook en dingen als SQL-injecties ziet een beetje programmeur dan ook direct.
Uiteraard is het een ander verhaal als je net begint met een bepaalde taal / je komt net van school maar dan had je waarschijnlijk een SQL-injectie van StackOverflow gekopieerd :-)

Op dit item kan niet meer gereageerd worden.