user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: Learning to Represent Programs with Graphs

Paper content:
Learning tasks on source code (i.e., formal languages) have been considered recently, but most work has tried to transfer natural language methods and does not capitalize on the unique opportunities offered by code's known syntax.
For example, long-range dependencies induced by using the same variable or function in distant locations are often not considered.
We propose to use graphs to represent both the syntactic and semantic structure of code and use graph-based deep learning methods to learn to reason over program structures.
In this work, we present how to construct graphs from source code and how to scale Gated Graph Neural Networks training to such large graphs.
We evaluate our method on two tasks: VarNaming, in which a network attempts to predict the name of a variable given its usage, and VarMisuse, in which the network learns to reason about selecting the correct variable that should be used at a given program location.
Our comparison to methods that use less structured program representations shows the advantages of modeling known structure, and suggests that our models learn to infer meaningful names and to solve the VarMisuse task in many cases.
Additionally, our testing showed that VarMisuse identifies a number of bugs in mature open-source projects.
The advent of large repositories of source code as well as scalable machine learning methods naturally leads to the idea of "big code", i.e., largely unsupervised methods that support software engineers by generalizing from existing source code BID4 .
Currently, existing deep learning models of source code capture its shallow, textual structure, e.g. as a sequence of tokens BID15 BID22 BID3 , as parse trees BID18 , or as a flat dependency networks of variables BID23 .
Such models miss out on the opportunity to capitalize on the rich and well-defined semantics of source code.
In this work, we take a step to alleviate this by including two additional signal sources in source code: data flow and type hierarchies.
We do this by encoding programs as graphs, in which edges represent syntactic relationships (e.g. "token before/after") as well as semantic relationships ("variable last used/written here", "formal parameter for argument is called stream", etc.).
Our key insight is that exposing these semantics explicitly as structured input to a machine learning model lessens the requirements on amounts of training data, model capacity and training regime and allows us to solve tasks that are beyond the current state of the art.We explore two tasks to illustrate the advantages of exposing more semantic structure of programs.
First, we consider the VARNAMING task BID1 BID23 , in which given some source code, the "correct" variable name is inferred as a sequence of subtokens.
This requires some understanding of how a variable is used, i.e., requires reasoning about lines of code far var clazz=classTypes ["Root"] .Single
() as JsonCodeGenerator.ClassType; Assert.NotNull(clazz); var first=classTypes ["RecClass"] .Single
() as JsonCodeGenerator.ClassType; Assert.NotNull( clazz ); Assert.Equal("string", first.Properties ["Name"] .Name); Assert.False(clazz.Properties ["Name"] .IsArray); Figure 1 : A snippet of a detected bug in RavenDB an open-source C# project. The code
has been slightly simplified. Our model
detects correctly that the variable used in the highlighted (yellow) slot is incorrect. Instead,
first should have been placed at the slot. We reported
this problem which was fixed in PR 4138. apart in the
source file. Secondly, we
introduce the variable misuse prediction task (VARMISUSE), in which the network aims to infer which variable should be used in a program location. To illustrate
the task, Figure 1 shows a slightly simplified snippet of a bug our model detected in a popular open-source project. Specifically,
instead of the variable clazz, variable first should have been used in the yellow highlighted slot. Existing static
analysis methods cannot detect such issues, even though a software engineer would easily identify this as an error from experience.To achieve high accuracy on these tasks, we need to learn representations of program semantics. For both tasks,
we need to learn the semantic role of a variable (e.g., "is it a counter?", "is it a filename?"). Additionally, for
VARMISUSE, learning variable usage semantics (e.g., "a filename is needed here") is required. This "fill the blank
element" task is related to methods for learning distributed representations of natural language words, such as Word2Vec BID20 and GLoVe BID21 . However, we can learn
from a much richer structure such as data flow information. This work is a step towards
learning program representations, and we expect them to be valuable in a wide range of other tasks, such as code completion ("this is the variable you are looking for") and more advanced bug finding ("you should lock before using this object").To summarize, our contributions
are: (i) We define the VARMISUSE task
as a challenge for machine learning modeling of source code, that requires to learn (some) semantics of programs (cf. section 3).(ii) We present deep learning models
for solving the VARNAMING and VARMISUSE tasks by modeling the code's graph structure and learning program representations over those graphs (cf. section 4). (iii) We evaluate our models on a large
dataset of 2.9 million lines of real-world source code, showing that our best model achieves 32.9% accuracy on the VARNAMING task and 85.5% accuracy on the VARMISUSE task, beating simpler baselines (cf. section 5). (iv) We document practical relevance of
VARMISUSE by summarizing some bugs that we found in mature open-source software projects (cf. subsection 5.3). Our implementation of graph neural networks
(on a simpler task) can be found at https://github.com/Microsoft/gated-graph-neural-network-samples and the dataset can be found at https://aka.ms/iclr18-prog-graphs-dataset.
Although source code is well understood and studied within other disciplines such as programming language research, it is a relatively new domain for deep learning.
It presents novel opportunities compared to textual or perceptual data, as its (local) semantics are well-defined and rich additional information can be extracted using well-known, efficient program analyses.
On the other hand, integrating this wealth of structured information poses an interesting challenge.
Our VARMISUSE task exposes these opportunities, going beyond simpler tasks such as code completion.
We consider it as a first proxy for the core challenge of learning the meaning of source code, as it requires to probabilistically refine standard information included in type systems.
A PERFORMANCE CURVES FIG4 shows the ROC and precision-recall curves for the GGNN model.
As the reader may observe, setting a false positive rate to 10% we get a true positive rate 5 of 73% for the SEENPROJTEST and 69% for the unseen test.
This suggests that this model can be practically used at a high precision setting with acceptable performance.

assistant: text: Programs have structure that can be represented as graphs, and graph neural networks can learn to find bugs on such graphs