CodeSearchNet Challenge

Evaluating the State of Semantic Code Search

Hamel Husain Miltiadis Allamanis
Ho-Hsiang Wu Marc Brockschmidt
Tiferet Gazit {miallama,mabrocks}@microsoft.com
{hamelsmu,hohsiangwu,tiferet}@github.com Microsoft Research
GitHub
ABSTRACT To tackle this problem, we have defined the CodeSearchNet
arXiv:1909.09436v1 [cs.LG] 20 Sep 2019

Semantic code search is the task of retrieving relevant code given a Challenge on top of a new CodeSearchNet Corpus. The Code-
natural language query. While related to other information retrieval SearchNet Corpus was programmatically obtained by scraping
tasks, it requires bridging the gap between the language used in open-source repositories and pairing individual functions with
code (often abbreviated and highly technical) and natural language their (processed) documentation as natural language annotation.
more suitable to describe vague concepts and ideas. It is large enough (2 million datapoints) to enable training of high-
To enable evaluation of progress on code search, we are releasing capacity deep neural models on the task. We discuss this process in
the CodeSearchNet Corpus and are presenting the CodeSearch- detail in section 2 and also release the data preprocessing pipeline
Net Challenge, which consists of 99 natural language queries with to encourage further research in this area.
about 4k expert relevance annotations of likely results from Code- The CodeSearchNet Challenge is defined on top of this, pro-
SearchNet Corpus. The corpus contains about 6 million functions viding realistic queries and expert annotations for likely results.
from open-source code spanning six programming languages (Go, Concretely, in version 1.0, it consists of 99 natural languages queries
Java, JavaScript, PHP, Python, and Ruby). The CodeSearchNet paired with likely results for each of six considered programming
Corpus also contains automatically generated query-like natural languages (Go, Java, JavaScript, PHP, Python, and Ruby). Each
language for 2 million functions, obtained from mechanically scrap- query/result pair was labeled by a human expert, indicating the
ing and preprocessing associated function documentation. In this relevance of the result for the query. We discuss the methodology
article, we describe the methodology used to obtain the corpus and in detail in section 3.
expert labels, as well as a number of simple baseline solutions for Finally, we create a number of baseline methods using a range
the task. of state-of-the-art neural sequence processing techniques (bag of
We hope that CodeSearchNet Challenge encourages researchers words, RNNs, CNNs, attentional models) and evaluate them on our
and practitioners to study this interesting task further and will host datasets. We discuss these models in section 4 and present some
a competition and leaderboard to track the progress on the chal- preliminary results.
lenge. We are also keen on extending CodeSearchNet Challenge
to more queries and programming languages in the future. 2 THE CODE SEARCH CORPUS
As it is economically infeasible to create a dataset large enough
for training high-capacity models using expert annotations, we
1 INTRODUCTION instead create a proxy dataset of lower quality. For this, we follow
The deep learning revolution has fundamentally changed how we other attempts in the literature [5, 6, 9, 11] and pair functions in
approach perceptive tasks such as image and speech recognition open-source software with the natural language present in their
and has shown substantial successes in working with natural lan- respective documentation. However, to do so requires a number
guage data. These have been driven by the co-evolution of large of preprocessing steps and heuristics. In the following, we discuss
(labelled) datasets, substantial computational capacity, and a num- some general principles and decisions driven by in-depth analysis
ber of advances in machine learning models. of common error cases.
However, deep learning models still struggle on highly structured
CodeSearchNet Corpus Collection. We collect the corpus from
data. One example is semantic code search: while search on natural
publicly available open-source non-fork GitHub repositories, using
language documents and even images has made great progress,
libraries.io to identify all projects which are used by at least one
searching code is often still unsatisfying. Standard information re-
other project, and sort them by “popularity” as indicated by the
trieval methods do not work well in the code search domain, as there
number of stars and forks. Then, we remove any projects that do
is often little shared vocabulary between search terms and results
not have a license or whose license does not explicitly permit the
(e.g. consider a method called deserialize_JSON_obj_from_stream
re-distribution of parts of the project. We then tokenize all Go, Java,
that may be a correct result for the query “read JSON data”). Even
JavaScript, Python, PHP and Ruby functions (or methods) using
more problematic is that evaluating methods for this task is ex-
TreeSitter — GitHub’s universal parser — and, where available, their
tremely hard, as there are no substantial datasets that were created
respective documentation text using a heuristic regular expression.
for this task; instead, the community tries to make do with small
datasets from related contexts (e.g. pairing questions on web forums Filtering. To generate training data for the CodeSearchNet
to code chunks found in answers). Challenge, we first consider only those functions in the corpus
 CodeSearchNet

Number of Functions 3 THE CODE SEARCH CHALLENGE

w/ documentation All To evaluate on the CodeSearchNet Challenge, a method has to
return a set of relevant results from CodeSearchNet Corpus for
Go 347 789 726 768 each of 99 pre-defined natural language queries. Note that the task
Java 542 991 1 569 889 is somewhat simplified from a general code search task by only
JavaScript 157 988 1 857 835 allowing full functions/methods as results, and not arbitrary chunks
PHP 717 313 977 821 of code.1 The CodeSearchNet Challenge evaluation dataset con-
Python 503 502 1 156 085 sists of the 99 queries with relevance annotations for a small number
Ruby 57 393 164 048 of functions from our corpus likely to be returned. These annota-
All 2 326 976 6 452 446 tions were collected from a small set of expert programmers, but we
Table 1: Dataset Size Statistics are looking forward to widening the annotation set going forward.
Query Collection. To ensure that our query set is representative,
we obtained common search queries from Bing that had high click-
through rates to code and combined these with intent rewrites
that have documentation associated with them. This yields a set in StaQC [24]. We then manually filtered out queries that were
of pairs (ci , di ) where ci is some function documented by di . To clearly technical keywords (e.g. the exact name of a function such
make the data more realistic proxy for code search tasks, we then as tf.gather_nd) to obtain a set of 99 natural language queries.
implement a number of preprocessing steps: While most of the collected queries are generic, some of them are
• Documentation di is truncated to the first full paragraph, to language-specific.
make the length more comparable to search queries and re-
move in-depth discussion of function arguments and return Expert Annotations. Obviously, we cannot annotate all query/-
values. function pairs. To filter this down to a more realistically-sized set,
• Pairs in which di is shorter than three tokens are removed, we used our implementations of baseline methods and ensembled
since we do not expect such comments to be informative. them (see section 4) to generate 10 candidate results per query and
• Functions ci whose implementation is shorter than three programming language. Concretely, we used ensembles of all neural
lines are removed, these often include unimplemented meth- models and ElasticSearch to generate candidate results, merge the
ods, getters, setters, etc. suggestions and pick the top 10. We used a simple web interface for
• Functions whose name contains the substring “test” are re- the annotation process. The web interface firsts shows instructions
moved. Similarly, we remove constructors and standard ex- (see Figure 1) and then allows the annotator to pick a program-
tension methods such as __str__ in Python or toString in ming language. Then, one query/function pair is shown at a time,
Java. as shown in Figure 2. A link to the origin of the shown function
• We remove duplicates from the dataset by identifying (near) is included, as initial experiments showed that some annotators
duplicate functions and only keeping one copy of them (we found inspecting the context of the code snippet helpful to judge
use the methods described in Allamanis [1], Lopes et al. [18]). relevance. The order of query/code pairs shown to the user is ran-
This removes multiple versions of auto-generated code and domized but weakly ordered by the number of expert annotations
cases of copy & pasting. already collected. Annotators are unlikely to see several results for
the same query unless they handle many examples. By randomizing
The filtered corpus and the data extraction code are released at
the order, we aim to allow users to score the relevance of each pair
https://github.com/github/CodeSearchNet.
individually without encouraging comparisons of different results
Dataset Statistics. The resulting dataset contains about 2 million for the same query.
pairs of function-documentation pairs and about another 4 million
Annotation Statistics. We collected 4 026 annotations across six
functions without an associated documentation (Table 1). We split
programming languages and prioritized coverage over multiple
the dataset in 80-10-10 train/valid/test proportions. We suggest that
annotations per query-snippet pair. Our annotators are volunteers
users of the dataset employ the same split.
with software engineering, data science and research roles and were
Limitations. Unsurpsingly, the scraped dataset is quite noisy. asked to only annotate examples for languages they had significant
First, documentation is fundamentally different from queries, and experience with. This led to a skewed distribution of annotations
hence uses other forms of language. It is often written at the same w.r.t. the considered programming languages.
time and by the same author as the documented code, and hence We observed that the obtained relevance scores are distributed
tends to use the same vocabulary, unlike search queries. Second, differently for each language (Table 2). For example, the relevance
despite our data cleaning efforts we are unable to know the extent scores for Python are evenly distributed across the four categories
to which each documentation di accurately describes its associated while for JavaScript the annotations are skewed towards lower
code snippet ci . For example, a number of comments are outdated relevance scores. There is a number of potential reasons for this,
with regard to the code that they describe. Finally, we know that such as the quality of the used corpus, language-specific interactions
some documentation is written in other languages, whereas our 1 Note that on a sufficiently large dataset, this is not a significant restriction: more com-
CodeSearchNet Challenge evaluation dataset focuses on English monly implemented functionality almost always appears factored out into a function
queries. somewhere.
CodeSearchNet Challenge

agreement to estimate the quality of the task. The agreement is

moderate with Cohen κ = 0.47. This is somewhat expected given
that this task was relatively open-ended, as we will discuss next.

Qualitative Observations. During the annotation process we made

some observations in discussions with the annotators and through
the notes they provided in the web interface (see Fig. 2). These com-
ments point to some general issues in implementing code search:

Code Quality A subset of the results being returned are func-

tionally correct code, but of low quality, even though they
originated in reasonably popular projects. In this context,
low quality refers to unsatisfactory readability, bad secu-
rity practices, known antipatterns and potentially slow code.
Some annotators felt the need to give lower relevance scores
Figure 1: Instructions provided to annotators. to low-quality code as they would prefer not to see such
results.
Query Ambiguity Queries are often ambiguous without addi-
tional context. For example, the query “how to determine if
a string is a valid word” can have different correct interpre-
tations depending on the domain-specific meaning of “valid
word”.
Library vs. Project Specific Often a search yields code that is
very specific to a given project (e.g. using internal utility
functions), whereas other times the code is very general
and verbose (e.g. containing code that could be factored out).
Which of these is preferable depends on the context of the
query, which we did not explicitly specify when asking for
annotations.
Context Some results were semantically correct, but not relying
on related helper functions and thus not self-contained. Some
annotators were uncertain if such results should be consid-
ered relevant.
Directionality A common problem in results were functions im-
plementing the inverse functionality of the query, e.g. “con-
vert int to string” would be answered by stringToInt. This
suggests that the baseline models used for pre-filtering have
Figure 2: Interface used for relevance annotation. trouble with understanding such semantic aspects.

Count by Relevance Score Total 3.1 Evaluation of Ranking Models

0 1 2 3 Annotations To track the progress on the CodeSearchNet Challenge we have
Go 62 64 29 11 166 deployed a Weights & Biases leaderboard at https://app.wandb.ai/
Java 383 178 125 137 823 github/codesearchnet/benchmark. We hope that this leaderboard
JavaScript 153 52 56 58 319 will allow the community to better compare solutions to the code
PHP 103 77 68 66 314 search task.
Python 498 511 537 543 2 089
Ruby 123 105 53 34 315 Metrics. We used normalized discounted cumulative gain (NDCG)
Table 2: Annotation Dataset Statistics to evaluate each competing method. NDCG is a commonly used
metric [19] in information retrieval. We compute two variants of
NDCG: (a) NDCG computed over the subset of functions with
human annotations (“Within”) (b) NDCG over the whole Code-
with our pre-filtering strategy, the queries we collected, higher SearchNet Corpus (“All”). We make this distinction as the NDCG
expected relevance standards in the JavaScript community, etc. score computed over the whole corpus may not necessarily repre-
For the 891 query-code pairs where we have more than one sent the quality of a search tool, as a new tool may yield relevant
annotation, we compute the squared Cohen’s kappa interannotator but not-annotated functions.
 CodeSearchNet

For all models, we set the dimensionality of the embedding space

to 128.
During training we are given a set of N pairs (ci , di ) of code and
natural language descriptions and have instantiated a code encoder
Ec and a query encoder Eq . We train by minimizing the loss
!
1 Õ exp(Ec (ci )⊤ Eq (di ))
− log Í ⊤ ,
N i j exp(Ec (c j ) Eq (di ))

i.e. maximize the inner product of the code and query encodings of
the pair, while minimizing the inner product between each ci and
the distractor snippets cj (i , j). Note that we have experimented
with other similar objectives (e.g. considering cosine similarity and
max-margin approaches) without significant changes in results on
our validation dataset. The code for the baselines can be found at
Figure 3: Model Architecture Overview.
https://github.com/github/CodeSearchNet.
At test time, we index all functions in CodeSearchNet Cor-
pus using Annoy. Annoy offers fast, approximate nearest neighbor
4 BASELINE CODESEARCH MODELS indexing and search. The index includes all functions in the Code-
We implemented a range of baseline models for the code search SearchNet Corpus, including those that do not have an associated
task, using standard techniques from neural sequence processing documentation comment.
and web search.
4.2 ElasticSearch Baseline
4.1 Joint Vector Representations for Code In our experiments, we additionally included ElasticSearch, a widely
Search used search engine with the default parameters. We configured it
with an index using two fields for every function in our dataset:
Following earlier work [11, 20], we use joint embeddings of code the function name, split into subtokens; and the text of the entire
and queries to implement a neural search system. Our architecture function. We use the default ElasticSearch tokenizer.
employs one encoder per input (natural or programming) language
and trains them to map inputs into a single, joint vector space. Our 4.3 Evaluation
training objective is to map code and the corresponding language
onto vectors that are near to each other, as we can then implement Following the training/validation/testing data split, we train our
a search method by embedding the query and then returning the set baseline models using our objective from above. While it does not
of code snippets that are “near” in embedding space. Although more directly correspond to the real target task of code search, it has
complex models considering more interactions between queries been widely used as a proxy for training similar models [6, 23].
and code can perform better [20], generating a single vector per For testing purposes on CodeSearchNet Corpus, we fix a set
query/snippet allows for efficient indexing and search. of 999 distractor snippets cj for each test pair (ci , di ) and test all
To learn these embedding functions, we combine standard se- trained models. Table 3 presents the Mean Reciprocal Rank results
quence encoder models in the architecture shown in Figure 3. on this task. Overall, we see that the models achieve relatively
First, we preprocess the input sequences according to their seman- good performance on this task, with the self-attention-based model
tics: identifiers appearing in code tokens are split into subtokens performing best. This is not unexpected, as the self-attention model
(i.e. a variable camelCase yields two subtokens camel and case), has the highest capacity of all considered models.
and natural language tokens are split using byte-pair encoding We have also run our baselines on CodeSearchNet Challenge
(BPE) [10, 21]. and show the results in Table 4. Here, the neural bag of words
Then, the token sequences are processed to obtain (contextual- model performs very well, whereas the stronger neural models on
ized) token embeddings, using one of the following architectures. the training task do less well. We note that the bag of words model
is particularly good at keyword matching, which seems to be a
Neural Bag of Words where each (sub)token is embedded to a crucial facility in implementing search methods. This hypothesis is
learnable embedding (vector representation). further validated by the fact that the non-neural ElasticSearch-based
Bidirectional RNN models where we employ the GRU cell [7] baseline performs the best among all baselines models we have
to summarize the input sequence. tested. As noted by Cambronero et al. [6], this can be attributed to
1D Convolutional Neural Network over the input sequence of the fact that the training data constructed from code documentation
tokens [15]. is not a good match for the code search task.
Self-Attention where multi-head attention [22] is used to com-
pute representations of each token in the sequence. 5 RELATED WORK
The token embeddings are then combined into a sequence embed- Applying machine learning to code has been widely considered [2].
ding using a pooling function, for which we have implemented A few academic works have looked into related tasks. First, seman-
mean/max-pooling and an attention-like weighted sum mechanism. tic parsing has received a lot of attention in the NLP community.
CodeSearchNet Challenge

Encoder CodeSearchNet Corpus (MRR)

Text Code Go Java JS PHP Python Ruby Avg
NBoW NBoW 0.6409 0.5140 0.4607 0.4835 0.5809 0.4285 0.6167
1D-CNN 1D-CNN 0.6274 0.5270 0.3523 0.5294 0.5708 0.2450 0.6206
biRNN biRNN 0.4524 0.2865 0.1530 0.2512 0.3213 0.0835 0.4262
SelfAtt SelfAtt 0.6809 0.5866 0.4506 0.6011 0.6922 0.3651 0.7011
Table 3: Mean Reciprocal Rank (MRR) on Test Set of CodeSearchNet Corpus. This evaluates for our training task, where
given the documentation comment as a query, the models try to rank the correct code snippet highly among 999 distractor
snippets.

Encoder CodeSearchNet Challenge– NDCG Within CodeSearchNet Challenge– NDCG All

Text Code Go Java JS PHP Python Ruby Avg Go Java JS PHP Python Ruby Avg
ElasticSearch 0.307 0.257 0.318 0.338 0.406 0.395 0.337 0.186 0.190 0.204 0.199 0.256 0.197 0.205
NBoW NBoW 0.221 0.179 0.226 0.194 0.279 0.382 0.247 0.130 0.121 0.175 0.123 0.223 0.212 0.164
1D-CNN 1D-CNN 0.132 0.246 0.131 0.332 0.341 0.327 0.252 0.059 0.128 0.044 0.135 0.166 0.115 0.108
biRNN biRNN 0.073 0.145 0.099 0.154 0.169 0.113 0.126 0.019 0.062 0.025 0.045 0.064 0.030 0.041
SelfAtt SelfAtt 0.096 0.140 0.139 0.184 0.292 0.417 0.211 0.049 0.100 0.061 0.094 0.181 0.190 0.113
Table 4: NDCG Baseline Results on CodeSearchNet Challenge. “Within” computes the NDCG only on the functions within
the human-annotated examples. “All” computes NDCG over all functions in the CodeSearchNet Corpus.

Although most approaches are usually aimed towards creating an in code. Researching neural methods that can efficiently and
executable representation of a natural language utterance with a accurately represent rare terms will improve performance.
domain-specific language, general-purpose languages have been • Code semantics such as control and data flow are not ex-
recently considered by Hashimoto et al. [13], Lin et al. [16], Ling ploited explicitly by existing methods, and instead search
et al. [17], Yin and Neubig [25]. methods seem to be mainly operate on identifiers (such as
Iyer et al. [14] generate code from natural language within the variable and function) names. How to leverage semantics to
context of existing methods, whereas Allamanis et al. [3], Alon improve results remains an open problem.
et al. [4] consider the task of summarizing functions to their names. • Recently, in NLP, pretraining methods such as BERT [8] have
Finally, Fernandes et al. [9] consider the task of predicting the found great success. Can similar methods be useful for the
documentation text from source code. encoders considered in this work?
More related to CodeSearchNet is prior work in code search • Our data covers a wide range of general-purpose code queries.
with deep learning. In the last few years there has been research in However, anecdotal evidence indicates that queries in spe-
this area ( Cambronero et al. [6], Gu et al. [11, 12], Yao et al. [23]), cific projects are usually more specialized. Adapting search
and architectures similar to those discussed previously have been methods to such use cases could yield substantial perfor-
shown to work to some extent. Recently, Cambronero et al. [6] mance improvements.
looked into the same problem that CodeSearchNet is concerned • Code quality of the searched snippets was a recurrent issue
with and reached conclusions similar to those discussed here. In with our expert annotators. Despite its subjective nature,
contrast to the aforementioned works, here we provide a human- there seems to be agreement on what constitutes very bad
annotated dataset of relevance scores and test a few more neural code. Using code quality as an additional signal that allows
search architectures along with a standard information retrieval for filtering of bad results (at least when better results are
baseline. available) could substantially improve satisfaction of search
users.
6 CONCLUSIONS & OPEN CHALLENGES
We hope that CodeSearchNet is a good step towards engaging REFERENCES
with the machine learning, IR and NLP communities towards devel- [1] Miltiadis Allamanis. 2018. The Adverse Effects of Code Duplication in Machine
oping new machine learning models that understand source code Learning Models of Code. arXiv preprint arXiv:1812.06469 (2018).
and natural language. Despite the fact this report gives emphasis [2] Miltiadis Allamanis, Earl T Barr, Premkumar Devanbu, and Charles Sutton. 2018.
A survey of machine learning for big code and naturalness. ACM Computing
on semantic code search we look forward to other uses of the pre- Surveys (CSUR) 51, 4 (2018), 81.
sented datasets. There are still plenty of open challenges in this [3] Miltiadis Allamanis, Hao Peng, and Charles Sutton. 2016. A Convolutional
Attention Network for Extreme Summarization of Source Code. In Proceedings of
area. the International Conference on Machine Learning (ICML).
• Our ElasticSearch baseline, that performs traditional keyword- [4] Uri Alon, Omer Levy, and Eran Yahav. 2018. code2seq: Generating sequences
from structured representations of code. arXiv preprint arXiv:1808.01400 (2018).
based search, performs quite well. It has the advantage of [5] Antonio Valerio Miceli Barone and Rico Sennrich. 2017. A parallel corpus of
being able to efficiently use rare terms, which often appear Python functions and documentation strings for automated code documentation
 CodeSearchNet

and code generation. arXiv preprint arXiv:1707.02275 (2017). Linux Operating System. In International Conference on Language Resources and
[6] Jose Cambronero, Hongyu Li, Seohyun Kim, Koushik Sen, and Satish Chandra. Evaluation.
2019. When Deep Learning Met Code Search. arXiv preprint arXiv:1905.03813 [17] Wang Ling, Edward Grefenstette, Karl Moritz Hermann, Tomas Kocisky, Andrew
(2019). Senior, Fumin Wang, and Phil Blunsom. 2016. Latent Predictor Networks for
[7] Kyunghyun Cho, Bart van Merriënboer, Dzmitry Bahdanau, and Yoshua Ben- Code Generation. In Proceedings of the Annual Meeting of the Association for
gio. 2014. On the Properties of Neural Machine Translation: Encoder–Decoder Computational Linguistics (ACL).
Approaches. Syntax, Semantics and Structure in Statistical Translation (2014). [18] Cristina V Lopes, Petr Maj, Pedro Martins, Vaibhav Saini, Di Yang, Jakub Zitny,
[8] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2018. Bert: Hitesh Sajnani, and Jan Vitek. 2017. DéjàVu: a map of code duplicates on GitHub.
Pre-training of deep bidirectional transformers for language understanding. arXiv Proceedings of the ACM on Programming Languages 1, OOPSLA (2017), 84.
preprint arXiv:1810.04805 (2018). [19] Christopher D. Manning, Prabhakar Raghavan, and Hinrich Schütze. 2008. Intro-
[9] Patrick Fernandes, Miltiadis Allamanis, and Marc Brockschmidt. 2018. Structured duction to Information Retrieval. Cambridge University Press.
Neural Summarization. arXiv preprint arXiv:1811.01824 (2018). [20] Bhaskar Mitra, Nick Craswell, et al. 2018. An introduction to neural information
[10] Philip Gage. 1994. A new algorithm for data compression. The C Users Journal retrieval. Foundations and Trends® in Information Retrieval 13, 1 (2018), 1–126.
12, 2 (1994), 23–38. [21] Rico Sennrich, Barry Haddow, and Alexandra Birch. 2016. Neural machine
[11] Xiaodong Gu, Hongyu Zhang, and Sunghun Kim. 2018. Deep code search. In 2018 translation of rare words with subword units. In Proceedings of the Annual Meeting
IEEE/ACM 40th International Conference on Software Engineering (ICSE). IEEE, of the Association for Computational Linguistics (ACL).
933–944. [22] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones,
[12] Xiaodong Gu, Hongyu Zhang, Dongmei Zhang, and Sunghun Kim. 2016. Deep Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017. Attention is all
API Learning. In Proceedings of the International Symposium on Foundations of you need. In Advances in Neural Information Processing Systems. 5998–6008.
Software Engineering (FSE). [23] Ziyu Yao, Jayavardhan Reddy Peddamail, and Huan Sun. 2019. CoaCor: Code
[13] Tatsunori B Hashimoto, Kelvin Guu, Yonatan Oren, and Percy S Liang. 2018. A Annotation for Code Retrieval with Reinforcement Learning. (2019).
retrieve-and-edit framework for predicting structured outputs. In Advances in [24] Ziyu Yao, Daniel S Weld, Wei-Peng Chen, and Huan Sun. 2018. StaQC: A Sys-
Neural Information Processing Systems. 10073–10083. tematically Mined Question-Code Dataset from Stack Overflow. In Proceedings of
[14] Srinivasan Iyer, Ioannis Konstas, Alvin Cheung, and Luke Zettlemoyer. 2018. Map- the 2018 World Wide Web Conference on World Wide Web. International World
ping language to code in programmatic context. arXiv preprint arXiv:1808.09588 Wide Web Conferences Steering Committee, 1693–1703.
(2018). [25] Pengcheng Yin and Graham Neubig. 2017. A Syntactic Neural Model for General-
[15] Yoon Kim. 2014. Convolutional neural networks for sentence classification. arXiv Purpose Code Generation. Proceedings of the Annual Meeting of the Association
preprint arXiv:1408.5882 (2014). for Computational Linguistics (ACL).
[16] Xi Victoria Lin, Chenglong Wang, Luke Zettlemoyer, and Michael D. Ernst. 2018.
NL2Bash: A Corpus and Semantic Parser for Natural Language Interface to the