Forskning vid skärningspunkten mellan maskininlärning, programmeringsspråk och programvaruteknik har nyligen tagit viktiga steg i att föreslå lärbara probabilistiska modeller av källkod som utnyttjar överflöd av mönster av kod. I den här artikeln undersöker vi det här arbetet. Vi kontrasterar programmeringsspråk mot naturliga språk och diskuterar hur dessa likheter och skillnader driver utformningen av probabilistiska modeller. Vi presenterar en taxonomi baserad på de underliggande designprinciperna för varje modell och använder den för att navigera i litteraturen. Sedan går vi igenom hur forskarna har anpassat dessa modeller till applikationsområden och diskuterat övergripande och tillämpningsspecifika utmaningar och möjligheter. M. Allamanis m.fl. Forskningen på detta område har dominerats av det formella, eller logiska, tillvägagångssättet. Utövare av detta tillvägagångssätt anser att, eftersom programvara är konstruerad i matematiskt väldefinierade programmeringsspråk, programvaruverktyg kan utformas i rent formella termer. Utformningen av programvaruverktyg är att närma sig med hjälp av formella metoder för definition, abstraktion, och avdrag. Egenskaper hos verktyg som byggts på detta sätt bör bevisas med hjälp av rigorösa bevistekniker såsom induktion över diskreta strukturer. Denna logik-deduktiva tillvägagångssätt har enorm dragningskraft i programmeringsspråk forskning, eftersom den håller löftet om att bevisa fakta och egenskaper i programmet. Många eleganta och kraftfulla abstraktioner, definitioner, algoritmer och bevistekniker har utvecklats, vilket har lett till viktiga praktiska verktyg för programverifiering, felsökning och refaktoring [24, 42, 45]. Det bör betonas att detta är teori-första angreppssätt. Programvarukonstruktioner betraktas främst som matematiska objekt, och vid utvärdering av programvaruverktyg som byggts med detta tillvägagångssätt, är elegansen och stelheten i definitioner, abstraktioner och formella bevis-av Properties av dominerande betydelse. De faktiska typerna av användning av programvara konstruerar, i praktiken, blir relevanta senare, i fallstudier, som vanligtvis åtföljer presentationer i denna typ av arbete. På senare tid har det uppstått en annan värdefull resurs: den stora och växande mängden framgångsrika, allmänt använda mjukvarusystem med öppen källkod. Programvara med öppen källkod såsom Linux, MySQL, Django, Ant och OpenEJB har blivit allmänt förekommande. Dessa system exponerar offentligt inte bara källkod utan även metadata om upphovsmannaskap, felrättelser och granskningsprocesser. Omfattningen av tillgängliga data är massiv: miljarder tokens av kod och miljontals fall av metadata, såsom ändringar, buggfixar, och kodrecensioner ("big code"). Tillgången till "stor kod" tyder på en ny, datadriven strategi för att utveckla programvaruverktyg: Varför inte låta de statistiska distributionsegenskaperna, bedömda över stora och representativa program corpora, också påverka utformningen av utvecklingsverktyg? Så snarare än att prestera bra i värsta fall, eller i fallstudier, våra verktyg kan prestera bra i de flesta fall, vilket ger större fördelar i förväntan. Attraktionskraften av detta tillvägagångssätt påminner om tidigare arbete inom dataarkitektur: Amdahls lag [15], till exempel, säger oss att fokusera på det vanliga fallet. Detta motiverar ett liknande hopp för utvecklingsverktyg, att verktyg för programvaruutveckling och programanalys kan förbättras genom att fokusera på de vanliga fallen med hjälp av en finkornig uppskattning av den statistiska fördelningen av kod. I grund och botten är förhoppningen att analysera texten i tusentals välskrivna programvaruprojekt kan avslöja mönster som delvis karakteriserar programvara som är tillförlitlig, lättläst och lätt att underhålla. Maskininlärningens löfte och kraft vilar på dess förmåga att generalisera från exempel och hantera buller. Hittills har forskning inom programvaruteknik (SE) och programmeringsspråk (PL) i stor utsträckning fokuserat på att använda maskininlärningsteknik (ML) som svarta lådor för att ersätta heuristik och hitta funktioner, ibland utan att uppskatta subtiliteterna i de antaganden som dessa tekniker gör. Ett viktigt bidrag till denna undersökning är att belysa dessa antaganden och deras konsekvenser. Precis som forskningen om naturligt språk (NLP) ändrade fokus från sköra regelbaserade expertsystem som inte kunde hantera mångfalden av verkliga data till statistiska metoder [99], bör SE/PL göra samma övergång, vilket utökar traditionella metoder som endast beaktar den formella strukturen av program med information om de statistiska egenskaperna hos kod. En undersökning av maskininlärning för stor kod och naturlighet 81.3 en "påse av ord" representation av kod, modellering kod med hjälp av sekvenser, träd, och kontinuerliga representationer. Vi beskriver ett brett spektrum av nya applikationer, allt från recommender-system, felsökning, programanalys och programsyntes. Den stora mängden arbete med semantisk tolkning [138] är inte fokus för denna undersökning, men vi inkluderar några metoder som utdatakodar i allmänna programmeringsspråk (snarare än noggrant utformade domänspecifika språk). Denna översyn är strukturerad enligt följande. Vi diskuterar först de olika egenskaperna hos naturligt språk och källkod för att motivera de designbeslut som ingår i maskininlärning modeller av kod (avsnitt 3). Vi inför sedan en taxonomi av probabilistiska modeller av källkod (avsnitt 4). Därefter beskriver vi programutvecklings- och programmeringsspråktillämpningarna för probabilistiska källkodsmodeller (avsnitt 5). Slutligen nämner vi några överlappande forskningsområden (avsnitt 7), och vi diskuterar utmaningar och intressanta framtida riktningar (avsnitt 6). Relaterade recensioner och andra resurser. Det har gjorts korta översikter som sammanfattar framstegen och visionen för forskningsområdet, både från programvaruteknik [52] och programmeringsspråk perspektiv [28, 195]. Men ingen av dessa artiklar kan betraktas som omfattande litteraturgenomgångar, vilket är syftet med detta arbete. Ernst [57] diskuterar lovande områden för att tillämpa behandling av naturligt språk på programvaruutveckling, inklusive felmeddelanden, variabelnamn, kodkommentarer och användarfrågor. Vissa resurser, datauppsättningar och koder finns på http://learnbigcode.github.io/. En online-version av det arbete som granskas här-som vi kommer att hålla uppdaterad genom att acceptera externa bidrag-kan hittas på https://ml4code.github.io. Många aspekter av kod, såsom namn, formatering, den lexikala ordningen av metoder, och så vidare, har ingen inverkan på program semantik. Det är just därför vi abstraherar dem i de flesta programanalyser. Men varför skulle då de statistiska egenskaperna hos kodsubstansen över huvud taget? För att förklara detta föreslog vi nyligen en hypotes, kallad naturalnesshypotesen. Inspirationen till naturalnesshypotesen kan spåras tillbaka till begreppet "litterär programmering" av D. Knuth, som utgår från insikten att programmering är en form av mänsklig kommunikation: "Låt oss ändra vår traditionella inställning till uppbyggnaden av program: Istället för att föreställa oss att vår huvuduppgift är att instruera en dator vad man ska göra, låt oss koncentrera oss snarare på att förklara för människor vad vi vill att en dator ska göra. .. " [105].................................................................................... Naturalness hypotesen, alltså, hävdar att Naturalness hypotesen. Programvara är en form av mänsklig kommunikation; programvara corpora har liknande statistiska egenskaper som naturligt språk corpora; och dessa egenskaper kan utnyttjas för att bygga bättre programvarutekniska verktyg. Utnyttjandet av statistiken över mänsklig kommunikation är en mogen och effektiv teknik, med många tillämpningar [99]. Stor korpora av mänsklig kommunikation, viz. naturligt språk corpora, har studerats ingående, och mycket förfinade statistiska modeller av dessa corpora har använts till stor effekt i taligenkänning, översättning, felkorrigering, och så vidare. Naturalness hypotesen hävdar att, eftersom kodning är en handling av kommunikation, kan man förvänta sig att stora kodkorpora har rika mönster, som liknar naturligt språk, vilket gör det möjligt för programvarutekniska verktyg att utnyttja probabilistiska ML-modeller. De första empiriska bevisen för denna hypotes, som visar att modeller som ursprungligen utvecklades för naturligt språk var förvånansvärt effektiva för källkod, presenterades av Hindle et al. [87, 88]................................................... Mer bevis och många tillämpningar av detta tillvägagångssätt har följts, som är föremål för denna översyn. Naturalnesshypotesen inspirerar därför målet att tillämpa maskininlärningsmetoder för att skapa probabilistiska källkodsmodeller som lär sig hur utvecklare naturligt skriver och använder kod. Dessa modeller kan användas för att förstärka befintliga verktyg med statistisk information och möjliggöra nya maskininlärning-baserade programvarutekniska verktyg, såsom recommender system och program 81.4 M. Allamanis et al. Analyser. På en hög nivå, statistiska metoder tillåter ett system för att göra hypoteser, tillsammans med probabilistiska förtroende värden, om vad en utvecklare kan vilja göra härnäst eller vilka formella egenskaper kan vara sant för en bit av kod. Probabilistiska metoder ger också naturliga sätt att lära sig korrespondens mellan kod och andra typer av dokument, såsom krav, blogginlägg, kommentarer, och så på sådana korrespondenser kommer alltid att vara osäker, eftersom naturligt språk är tvetydigt, och därför det kvantitativa mått på förtroende som tillhandahålls av sannolikheter är särskilt naturligt. Som vi diskuterar i avsnitt 5 skulle man kunna gå så långt som att hävda att nästan alla områden inom programvaruteknik och programmeringsspråkforskning har möjligheter att utnyttja statistiska egenskaper. Även om "naturlighetshypotesen" kanske inte verkar förvånande, bör man inse den grundläggande orsaken till "naturlighet". Naturlighet i kod verkar ha en stark koppling till det faktum att utvecklare föredrar att skriva [5] och läsa [85] kod som är konventionell, idiomatisk, och bekant, eftersom det hjälper till att förstå och underhålla mjukvarusystem. Kod som tar välbekanta former är öppnare, eftersom dess betydelse är lättare att förstå för en erfaren läsare. Således leder naturalness hypotes sömlöst till en "kod förutsägbarhet" begrepp, vilket tyder på att kod artefakter-från enkla token sekvenser till formella verifiering uttalanden-innehålla användbara återkommande och förutsägbara mönster som kan utnyttjas. "Naturlighet" och "stor kod" bör ses som exempel på ett mer allmänt begrepp att det finns exploaterbar regelbundenhet över mänskligt skriven kod som kan "absorberas" och generaliseras av en lärande komponent som kan överföra sin kunskap och probabilistiskt resonera om ny kod. I den här artikeln granskas det framväxande området för maskininlärning och statistiska metoder för bearbetning av naturligt språk som tillämpas på källkod. Vi fokuserar på probabilistiska modeller av kod, det vill säga metoder som uppskattar en distribution över alla möjliga källfiler. Maskininlärning i probabilistiska modeller har sett en bred tillämpning genom artificiell intelligens, inklusive behandling av naturligt språk, robotik och datorseende, på grund av dess förmåga att hantera osäkerhet och lära sig inför bullriga data. Man kan rimligtvis fråga varför det är nödvändigt att hantera osäkerhet och buller i programutvecklingsverktyg, när i många fall det program som ska analyseras är känt (det finns ingen osäkerhet om vad programmeraren har skrivit) och är deterministiskt. Faktum är att det finns flera intressanta motiv för att införliva probabilistisk modellering i maskininlärningsmetoder för programvaruutveckling. För det första erbjuder probabilistiska metoder en principiell metod för att hantera osäkerhet och sammansmältning av flera, möjligen tvetydiga, informationskällor. För det andra ger probabilistiska modeller ett naturligt ramverk för att koppla förkunskaper till data-tillhandahålla ett naturligt ramverk för att designa metoder baserade på abstraktioner av statistiska egenskaper kodkorpora. I synnerhet vill vi ofta dra slutsatser om samband mellan källkod och text i naturligt språk, såsom kommentarer, felrapporter, kravdokument, dokumentation, sökfrågor och så vidare. Eftersom texten i naturligt språk är tvetydig, är det användbart att kvantifiera osäkerheten i överensstämmelsen mellan kod och text. Slutligen, när förutsäga programegenskaper, sannolikheter ger ett sätt att slappna av strikta krav onsoundness: Vi kan söka osunda metoder som förutsäger programegenskaper baserat på statistiska mönster i koden, med sannolikheter som ett sätt att kvantifiera metodens förtroende för dess förutsägelser. Programmeringsspråk minskar klyftan mellan datorer och det mänskliga sinnet: De konstruerar välsmakande abstraktioner ur en mängd små statsövergångar. Källkoden har två målgrupper och är i sig bimodal: Den kommunicerar längs två kanaler, en med människor och en med datorer. Människor måste förstå koden för att läsa och skriva den; datorer måste kunna köra den. Kodens dubbelmodalitet driver fram likheterna och skillnaderna mellan den och texten. Nedan diskuterar vi dessa likheter och skillnader med framåtriktade tecken på hur de har utnyttjats,
Det finns ett stort arbete med statistiska modeller för källkod (se REF ).
A Survey of Machine Learning for Big Code and Naturalness
{'venue': 'CSUR', 'journal': None, 'mag_field_of_study': ['Computer Science']}