Naturliga språkelement i källkoden, t.ex. namn på variabler och funktioner, förmedlar användbar information. De flesta befintliga felsökningsverktyg ignorerar dock denna information och missar därför vissa klasser av fel. De få befintliga namnbaserade feldetekteringen närmar sig förnuftet om namn på en syntaktisk nivå och förlitar sig på manuellt utformade och avstämda algoritmer för att upptäcka fel. Detta dokument presenterar DeepBugs, en inlärningsmetod för namnbaserad feldetektering, som resonerar om namn baserade på en semantisk representation och som automatiskt lär sig feldetektorer istället för att skriva dem manuellt. Vi formulerar bugg detektion som ett binärt klassificeringsproblem och utbildar en klassificering som skiljer korrekt från felaktig kod. För att ta itu med utmaningen att effektivt lära sig en bugg detektor kräver exempel på både korrekt och felaktig kod, vi skapar sannolikt felaktiga kodexempel från en befintlig corpus av kod genom enkla kodomvandlingar. En ny insikt som vi lärt oss av vårt arbete är att lära av artificiellt sådda buggar ger buggdetektorer som är effektiva på att hitta buggar i verkliga koden. Vi implementerar vår idé i ett ramverk för inlärningsbaserad och namnbaserad feldetektering. Tre bugg detektorer byggda ovanpå ramen upptäcka oavsiktligt bytte funktion argument, felaktiga binära operatörer, och felaktiga operander i binära operationer. Tillämpar metoden på en corpus av 150.000 JavaScript-filer ger bugg detektorer som har en hög noggrannhet (mellan 89% och 95%), är mycket effektiva (mindre än 20 millisekunder per analyserad fil), och avslöja 102 programmeringsfel (med 68% sann positiv hastighet) i real-world-kod. Tidigare arbete med namnbaserad feldetektering [Hst och Østvold 2009; Pradel och Gross 2011; Rice et al. 2017 ] tar itu med dessa utmaningar genom lexiskt resonemang om identifierare och genom manuellt utformade algoritmer. För att resonera om betydelsen av identifierare, dessa metoder använder lexikala likheter av namn som en proxy för semantisk likhet. Till exempel, de befintliga tillvägagångssätten kan finna längd och len vara liknande eftersom de delar en gemensam delsträng, men missa det faktum att längd och räkna är semantiskt liknande även om de är lexiskt olika. Att fatta beslut om program, t.ex., att rapportera en kodbit som sannolikt felaktig, befintliga namnbaserade analyser förlitar sig på manuellt utformade algoritmer som använder hårdkodade mönster och noggrant inställda heuristik. Till exempel, en namnbaserad analys som nyligen har satts in på Google [Rice et al. 2017 ] kommer med olika heuristik för att öka antalet upptäckta buggar och för att minska antalet falska positiva. Att utforma och finjustera sådana heuristiker kräver en betydande mänsklig ansträngning som är svår att återanvända över olika analyser och olika klasser av buggar. Detta dokument tar itu med problemet med namnbaserad feldetektering med ett maskininlärningsbaserat tillvägagångssätt. För att ta itu med problemet med resonemang om betydelsen av identifierare använder vi en inlärd vektorrepresentation av identifierare. Denna representation, som kallas inbäddningar, bevarar semantiska likheter, till exempel det faktum att längd och antal är lika. Sådana inbäddningar har varit framgångsrika för flera naturliga språkbearbetningsuppgifter och att anta dem till källkod är ett naturligt val för namnbaserad feldetektering. För att ta itu med problemet med att avgöra om en kod är sannolik eller felaktig formulerar vi problemet som binär klassificering och utbildar en modell för att skilja rätt från felaktig kod. Eftersom klassificeringen lärs ut utan mänsklig inblandning, förlitar sig metoden inte på att utforma och stämma heuristik. För att effektivt kunna lära sig en klassificering som skiljer sig från felaktig kod krävs utbildningsdata som består av både korrekta och felaktiga exempel. Exempel på korrekt kod är lätt tillgängliga på grund av de enorma mängder av befintlig kod, baserat på det gemensamma antagandet att de flesta delar av de flesta koderna är korrekta. Däremot är stora mängder kodexempel som är felaktiga av en specifik anledning mycket svårare att hitta. I synnerhet, att manuellt få en tillräckligt stor datauppsättning skulle kräva en människa för att märka tusentals buggar. För att ta itu med detta problem, genererar vi stora mängder träningsdata via enkla program transformationer som infogar sannolika buggar i befintliga, förmodligen korrekt kod. En viktig insikt i vårt arbete är att lärande från sådana artificiellt genererade träningsdata ger en inlärd modell som är effektiv för att identifiera verkliga buggar. Vi implementerar våra idéer i ett extensibelt ramverk, DeepBugs, som stöder olika klasser av namnrelaterade fel. Ramen tar fram positiva träningsexempel från en kod corpus, tillämpar en enkel omvandling för att också skapa stora mängder negativa utbildningsexempel, tränar en modell för att skilja dessa två, och slutligen använder den utbildade modellen för att identifiera misstag i tidigare osedda kod. Vi presenterar tre bugg detektorer baserade på DeepBugs som hittar oavsiktligt bytte funktion argument, felaktiga binära operatörer, och felaktiga operander i binära operationer. Att skapa en ny buggdetektor består av två enkla steg. Först, ge en utbildning datagenerator som extraherar korrekta och felaktiga kodexempel från en given corpus kod. För det andra, mappa varje kodexempel till en vektor som maskininlärningsmodellen lär sig att klassificera som korrekt eller inkorrekt. För det andra steget, alla bugg detektorer återanvända samma inbäddning av identifierare namn, förenkla uppgiften att skapa en namnbaserad bugg detektor. Vårt tillvägagångssätt skiljer sig från befintliga feldetektorer som identifierar fel som anomalier i en kodkorpus [Engler et al. 2001; Hangal och Lam 2002; Monperrus et al. År 2010 )........................................................................................................... Dessa närmar sig härleda information från befintlig kod genom att lära sig endast från korrekta exempel och sedan flagga någon kod som ovanliga som avviker från normen. För att minska falska positiva, dessa metoder normalt filtrera upptäckta anomalier baserat på manuellt utformade heuristik. I stället lär vi oss av positiva och negativa exempel, vilket gör det möjligt för modellen för maskininlärning att exakt skilja mellan
I DeepBugs Ref-dokumentet presenteras ett inlärningsbaserat tillvägagångssätt för att identifiera namnbaserade fel.
DeepBugs: a learning approach to name-based bug detection
{'venue': 'PACMPL', 'journal': None, 'mag_field_of_study': ['Computer Science']}