Back

Multilingual Code Snippets Training for Program Translation

Ming ZhuKarthik SureshChandan K. Reddy

article2022AAAI80 citations

Introduces a parallel snippet-level dataset across seven programming languages alongside a multilingual pre-training method that significantly improves source-to-source code translation, particularly for low-resource languages.

Listen

Modern organizations face substantial expenses and technical risks when adapting software across different platforms or migrating legacy systems to modern programming languages. Automated program translation aims to convert source code from one language to another, replacing manual, labor-intensive rule crafting with neural machine learning models. However, the development of reliable automated models has been heavily constrained by the lack of high-quality, parallel code datasets. Existing benchmarks are mostly limited to two languages or rely on coarse, program-level problem solutions that exhibit high variance in logic, variable names, and code structure.

The article introduces a fine-grained multilingual dataset and demonstrates a novel snippet-based pre-training strategy to improve program translation accuracy across diverse programming languages. Specifically, the authors evaluate whether pre-training on finely aligned code snippets can improve translation performance across 42 language pairs, with a particular focus on low-resource programming languages.

To accomplish this, the authors constructed the Code Snippet Translation dataset, compiling over 132,000 manually verified, aligned code snippets spanning seven popular languages—C, C++, C#, Java, JavaScript, PHP, and Python—across 1,625 programming problems. Using this data, they developed a sequence-to-sequence model termed MuST-PT. The model leverages a three-stage training strategy: initializing with a code-trained base model, performing multilingual denoising auto-encoding to establish a shared latent representation across all seven languages, and executing multilingual snippet translation pre-training before fine-tuning on full programs.

The findings show that the proposed approach outperforms existing baseline models across both snippet-level and full program-level evaluations. First, the model achieved state-of-the-art results on standard public benchmarks, reaching translation accuracy scores of 87.37 on Java-to-C# and 85.25 on C#-to-Java. Second, fine-grained snippet training significantly improved results for low-resource languages, such as PHP and C, where traditional models routinely fail due to data scarcity. Third, while baseline models experienced severe performance degradation when transitioning from short snippets to full-length programs, the proposed method maintained stable accuracy across long sequences. Finally, integrating this snippet-level pre-training into external baseline models yielded consistent, substantial performance gains, proving the generalizability of the training framework.

These results demonstrate that snippet-level alignment effectively addresses the sequence length and data imbalance challenges inherent to automated code translation. By transferring knowledge from resource-rich languages to data-scarce languages, this approach can significantly reduce the costs, timelines, and error rates associated with enterprise code migration. Organizations considering automated code conversion should prioritize fine-grained, snippet-aligned pre-training workflows over coarse program-level methods to enhance reliability. Future initiatives should explore applying these snippet-aligned techniques to adjacent software engineering tasks, including automated code summarization, documentation generation, and text-to-code synthesis.

While the findings provide strong confidence in the efficacy of snippet-level pre-training, stakeholders should note certain limitations. The dataset was collected from curated programming solutions following specific commenting templates, which may not capture all architectural complexities or non-standard coding styles encountered in large enterprise software repositories. Consequently, teams should validate model outputs on their specific domain codebases before broad operational deployment.

Virginia Techsource codesmultilingual code snippets trainingprogram translationmultilingual snippet translation
Zhu et al (2022).pdf
Cover for Multilingual Code Snippets Training for Program Translation

Abstract

Program translation aims to translate source code from one programming language to another. It is particularly useful in applications such as multiple-platform adaptation and legacy code migration. Traditional rule-based program translation methods usually rely on meticulous manual rule-crafting, which is costly both in terms of time and effort. Recently, neural network based methods have been developed to address this problem. However, the absence of high-quality parallel code data is one of the main bottlenecks which impedes the development of program translation models. In this paper, we introduce CoST, a new multilingual Code Snippet Translation dataset that contains parallel data from 7 commonly used programming languages. The dataset is parallel at the level of code snippets, which provides much more fine-grained alignments between different languages than the existing translation datasets. We also propose a new program translation model that leverages multilingual snippet denoising auto-encoding and Multilingual Snippet Translation (MuST) pre-training. Extensive experiments show that the multilingual snippet training is effective in improving program translation performance, especially for low-resource languages. Moreover, our training method shows good generalizability and consistently improves the translation performance of a number of baseline models. The proposed model outperforms the baselines on both snippet-level and program-level translation, and achieves state-of-the-art performance on CodeXGLUE translation task. The code, data, and appendix for this paper can be found at https://github.com/reddy-lab-code-research/MuST-CoST.

Topics

source codes

Keywords

multilingual code snippets trainingprogram translationmultilingual snippet translationcode translation datasetsCodeXGLUE translation taskrule-based program translationsnippet-level alignmentcode generationprogramming language pairs

Table of Contents

  • Introduction
  • Related Work
  • The Code Snippets Translation( CoST ) Dataset
  • Data Collection and Processing
  • Dataset Comparisons and Characteristics
  • The Proposed Method
  • Problem Formulation
  • Model Architecture
  • Model Initialization
  • Multilingual Snippet Denoising Auto-Encoding
  • Multilingual Snippet Translation (MuST)
  • Implementation Details
  • Experiments
  • Datasets
  • Evaluation Metrics
  • Baseline Methods
  • Results Analysis
  • Conclusion and Future Work
  • Acknowledgments
  • References

Knowls

  1. Knowl 1 — CoST Multilingual Code Snippet Translation Dataset

    definition

    The Code Snippet Translation (CoST) dataset is a parallel benchmark for program translation spanning 7 high-level programming languages: C, C++, C#, Python, Java, JavaScript, and PHP, derived from 1,625 programming problems on GeeksForGeeks.

    CoST provides parallel mappings at two distinct granularity levels across up to 42 directed language pairs (7×67 \times 6):

    1. Snippet level: Fine-grained code segments aligned across languages by leveraging standardized comment templates used by contributors, followed by manual verification and duplicate removal. In total, the dataset contains 132,046 parallel snippet pairs.
    2. Program level: Complete source code implementations solving the target programming problems, maintaining consistent variable names, method designs, and logic flows across languages.

    Data splits (train, validation, test) are partitioned strictly at the problem level to guarantee that no overlapping snippets or programs exist between splits across any language.

  2. Knowl 2 — CoST Dataset Pairwise Statistics

    data/table

    The CoST dataset contains pairwise parallel data across 7 programming languages at both snippet and program levels. The table below presents the pairwise instance counts. The upper triangle denotes the number of parallel code snippet pairs, while the lower triangle (in bold) denotes the number of parallel full-program pairs.

    C++ Java Py C# JS PHP C
    C++ – 13929 11930 13326 7596 3165 2188
    Java 1497 – 11713 13905 7729 3194 2135
    Py 1419 1417 – 11404 7165 3123 1779
    C# 1442 1495 1383 – 7601 3192 2123
    JS 996 1009 962 994 – 2917 1232
    PHP 548 552 545 552 512 – 700
    C 267 281 263 273 196 135 –

    The counts illustrate a notable data size imbalance across language pairs: high-resource pairs such as Java--C++ and Java--C# have over 13,000 snippet pairs and ~1,450 program pairs, whereas low-resource pairs such as C--PHP have only 700 snippet pairs and 135 program pairs.

  3. Knowl 3 — MuST-PT Model Architecture and Conditioning

    model/method

    The Multilingual Snippet Training for Program Translation (MuST-PT) model is a sequence-to-sequence Transformer comprising an encoder EE with 12 layers and a decoder GG with 6 layers, with model hidden dimension d=768d = 768 and 12 attention heads.

    To handle translation across multiple programming languages within a shared parameter space, language conditioning is performed via learned language identifier embeddings αl∈Rd\alpha_{l} \in \mathbb{R}^d for each language l∈Ll \in \mathcal{L}:

    • Given an input token sequence x=(x1,…,xn)x = (x_1, \dots, x_n) in language lil_i, the identifier embedding αli\alpha_{l_i} is added elementwise to each token representation, yielding (x1+αli,…,xn+αli)(x_1 + \alpha_{l_i}, \dots, x_n + \alpha_{l_i}) as encoder input.
    • The encoder produces latent representation z=E(x,αli)z = E(x, \alpha_{l_i}).
    • The decoder GG takes encoder state zz together with the target language identifier αlj\alpha_{l_j} to autoregressively decode output token sequence y=G(z,αlj)y = G(z, \alpha_{l_j}).

    The model parameters are initialized from the pre-trained weights of the DOBF model (dobf_plus_denoising.pth), which was pre-trained on Java and Python source code using masked language modeling and code deobfuscation objectives.

  4. Knowl 4 — Multilingual Snippet Denoising Auto-Encoding Objective

    equation

    To initialize representations for programming languages not covered by base pre-training (C++, C#, JavaScript, PHP, C) and map all languages into a unified latent space, a multilingual snippet Denoising Auto-Encoding (DAE) loss is minimized over monolingual snippets from all languages L\mathcal{L}:

    LDAE(θE,θG)=∑li∈LEx∼Dlimono,x~∼C(x)[−log⁡pG(x∣E(x~,αli),αli)]\mathcal{L}_{\text{DAE}}(\theta_E, \theta_G) = \sum_{l_i \in \mathcal{L}} \mathbb{E}_{x \sim \mathcal{D}_{l_i}^{\text{mono}}, \tilde{x} \sim C(x)} \left[ -\log p_G\left(x \mid E(\tilde{x}, \alpha_{l_i}), \alpha_{l_i}\right) \right]

    where:

    • L\mathcal{L} is the set of all 7 target programming languages,
    • Dlimono\mathcal{D}_{l_i}^{\text{mono}} denotes the dataset of monolingual code snippets in language lil_i,
    • C(x)C(x) is a stochastic non-learnable corruption function applying random word shuffling, random word dropout, and random span masking to input sequence xx,
    • αli\alpha_{l_i} is the language identifier embedding for language lil_i,
    • θE\theta_E and θG\theta_G denote the trainable parameters of encoder EE and decoder GG, respectively.

  5. Knowl 5 — Multilingual Snippet Translation (MuST) Training Objective

    equation

    The Multilingual Snippet Translation (MuST) objective optimizes cross-lingual snippet generation across all bilingual snippet pairs in language set L\mathcal{L}:

    LM(θE,θG)=∑li,lj∈LE(x,y)∼Dli,ljbi[−log⁡pG(y∣E(x,αli),αlj)]\mathcal{L}_{\text{M}}(\theta_E, \theta_G) = \sum_{l_i, l_j \in \mathcal{L}} \mathbb{E}_{(x, y) \sim \mathcal{D}_{l_i, l_j}^{\text{bi}}} \left[ -\log p_G\left(y \mid E(x, \alpha_{l_i}), \alpha_{l_j}\right) \right]

    where Dli,ljbi\mathcal{D}_{l_i, l_j}^{\text{bi}} is the parallel snippet dataset between source language lil_i and target language ljl_j, and αli,αlj\alpha_{l_i}, \alpha_{l_j} are their corresponding language identifier embeddings.

    The overall snippet pre-training objective balances translation and denoising auto-encoding:

    L=LM+λLDAE\mathcal{L} = \mathcal{L}_{\text{M}} + \lambda \mathcal{L}_{\text{DAE}}

    where λ\lambda is a dynamic weighting hyperparameter initialized to λ=1.0\lambda = 1.0, decayed linearly to 0.10.1 over the first 30k30\text{k} training steps, and subsequently decayed to 00 at 100k100\text{k} steps.

  6. Knowl 6 — MuST-PT Three-Stage Training Pipeline

    model/method

    The MuST-PT framework trains a program translation model via a three-stage sequence designed to overcome language scarcity and the difficulty of capturing long-range dependencies in full programs:

    1. DOBF Initialization: Encoder and decoder weights are initialized from a pre-trained Transformer model trained on code deobfuscation and masked language modeling over Java and Python.
    2. Multilingual Snippet Pre-training (DAE + MuST): The model is trained jointly on monolingual snippet denoising (DAE) and bilingual snippet translation (MuST) across all 42 language pairs. Snippet-level parallel data provides fine-grained alignment and enables cross-lingual knowledge transfer from high-resource pairs (e.g., C++--PHP, Java--PHP) to low-resource pairs (e.g., C--PHP).
    3. Multilingual Program-Level Fine-Tuning: The snippet-pre-trained model is fine-tuned on full program pairs across all language pairs using the sequence-to-sequence multilingual objective to bridge the sequence length and structural distribution gap between snippets and complete programs.

  7. Knowl 7 — Program Translation Performance on CodeXGLUE Benchmark

    data/table

    Evaluation of MuST-PT against baseline methods on the standard CodeXGLUE Java ↔\leftrightarrow C# program translation benchmark using BLEU and CodeBLEU metrics.

    Java-C# C#-Java
    Method BLEU CodeBLEU BLEU CodeBLEU
    Naive copy 18.54 – 18.69 –
    PBSMT 43.53 42.71 40.06 43.48
    Transformer 55.84 63.74 50.47 61.59
    RoBERTa(code) 77.46 83.07 71.99 80.18
    CodeBERT 79.92 85.10 72.14 79.41
    GraphCodeBERT 80.58 – 72.64 –
    PLBART 83.02 87.92 78.35 85.27
    MuST-PT 87.37 86.82 85.25 86.09

    MuST-PT establishes state-of-the-art BLEU scores on both translation directions (87.37 on Java→\rightarrowC# and 85.25 on C#→\rightarrowJava, exceeding PLBART by +4.35 and +6.90 BLEU points, respectively), and achieves high CodeBLEU scores (86.82 and 86.09), confirming that snippet pre-training transfers effectively to external program translation datasets.

  8. Knowl 8 — Snippet-Level and Program-Level Translation Performance on CoST

    empirical result

    Across all 42 language pairs of the CoST benchmark, MuST-PT outperforms baseline models (Naive Copy, Transformer, CodeBERT, and DOBF) on both snippet-level and program-level translation evaluated by BLEU:

    • Snippet-level: MuST-PT achieves the highest BLEU on all pairs, with particularly large gains in low-resource settings (e.g., C→\rightarrowPHP reaches 82.94 vs. DOBF's 22.22; PHP→\rightarrowC reaches 76.67 vs. DOBF's 23.78).
    • Program-level degradation resistance: Baseline models suffer substantial BLEU drops when moving from snippets to programs due to longer sequence lengths and smaller training sets (e.g., on C++→\rightarrowJava, DOBF drops from 79.83 snippet BLEU to 29.06 program BLEU; Transformer drops from 68.74 to 43.93). In contrast, MuST-PT maintains high program translation scores (79.15 on C++→\rightarrowJava, 89.93 on Java→\rightarrowC#, and 84.20 on C++→\rightarrowC).
    • Low-resource program translation: On low-resource pairs such as C→\rightarrowPHP and PHP→\rightarrowC, MuST-PT achieves program BLEU scores of 70.62 and 67.88 respectively, whereas baselines fail to exceed 26.0 BLEU.

  9. Knowl 9 — Generalizability of MuST Pre-Training to Baseline Translation Models

    data/table

    Multilingual Snippet Translation (MuST) pre-training can be incorporated into other model architectures prior to program fine-tuning. The table reports program-level translation BLEU scores on selected CoST language pairs for baseline models before and after applying MuST pre-training.

    Model Java-Py Py-Java Java-C++ C++-Java Java-C# C#-Java Py-C++ C++-Py Py-C# C#-Py C++-C# C#-C++
    Naive Copy 34.56 34.27 66.53 66.57 77.15 77.23 36.58 36.58 35.69 35.76 67.22 67.16
    Transformer 31.22 38.15 44.38 43.93 47.34 45.60 37.42 33.90 36.91 32.64 45.32 42.65
    Transformer+MuST 40.90 43.97 58.35 54.61 73.70 71.68 42.86 39.06 43.42 42.34 57.84 57.49
    CodeBERT 38.70 41.35 65.48 53.47 85.46 82.45 43.96 38.37 46.40 41.10 63.01 67.17
    CodeBERT+MuST 55.50 57.66 81.09 78.69 90.47 86.76 58.91 55.98 59.13 55.45 79.05 81.54
    TransCoder 24.98 21.98 30.09 30.42 44.85 29.40 23.03 23.52 40.40 18.81 41.91 25.30
    TransCoder+MuST 60.73 65.53 87.09 81.64 91.74 27.70 68.70 62.92 66.52 16.88 82.40 29.44

    Adding MuST pre-training yields consistent and large performance improvements across architectures: Transformer improves by up to +26.36 BLEU (Java→\rightarrowC#), CodeBERT improves by up to +25.22 BLEU (C++→\rightarrowJava), and TransCoder improves by up to +57.00 BLEU (Java→\rightarrowC++).

Coverage note — Omitted only the full 42x42 numeric entries of Table 4 in favor of a synthesized empirical result highlighting its core findings, as well as external pre-training objectives of prior models (DOBF and BART) described in related work.

References

  1. 1.Ahmad, W.; Chakraborty, S.; Ray, B.; and Chang, K.-W. 2021. Unified Pre-training for Program Understanding and Generation. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, 2655–2668. Online: Association for Computational Linguistics.
  2. 2.Brockschmidt, M.; Allamanis, M.; Gaunt, A. L.; and Polozov, O. 2018. Generative Code Modeling with Graphs. In International Conference on Learning Representations.
  3. 3.Chen, X.; Liu, C.; and Song, D. 2018. Tree-to-tree Neural Networks for Program Translation. In Bengio, S.; Wallach, H.; Larochelle, H.; Grauman, K.; Cesa-Bianchi, N.; and Garnett, R., eds., Advances in Neural Information Processing Systems, volume 31. Curran Associates, Inc.
  4. 4.Feng, Z.; Guo, D.; Tang, D.; Duan, N.; Feng, X.; Gong, M.; Shou, L.; Qin, B.; Liu, T.; Jiang, D.; and Zhou, M. 2020. CodeBERT: A Pre-Trained Model for Programming and Natural Languages. In Findings of the Association for Computational Linguistics: EMNLP 2020, 1536–1547. Online: Association for Computational Linguistics.
  5. 5.Guo, D.; Ren, S.; Lu, S.; Feng, Z.; Tang, D.; Liu, S.; Zhou, L.; Duan, N.; Svyatkovskiy, A.; Fu, S.; et al. 2020. Graphcodebert: Pre-training code representations with data flow. arXiv preprint arXiv:2009.08366.
  6. 6.Karaivanov, S.; Raychev, V.; and Vechev, M. 2014. Phrase-based statistical translation of programming languages. In Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming & Software, 173–184.
  7. 7.Kenton, J. D. M.-W. C.; and Toutanova, L. K. 2019. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. In Proceedings of NAACL-HLT, 4171–4186.
  8. 8.Kingma, D. P.; and Ba, J. 2014. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980.
  9. 9.Lample, G.; and Conneau, A. 2019. Cross-lingual Language Model Pretraining. arXiv e-prints, arXiv–1901.
  10. 10.Lample, G.; Conneau, A.; Denoyer, L.; and Ranzato, M. 2018. Unsupervised Machine Translation Using Monolingual Corpora Only. In International Conference on Learning Representations.
  11. 11.Lewis, M.; Liu, Y.; Goyal, N.; Ghazvininejad, M.; Mohamed, A.; Levy, O.; Stoyanov, V.; and Zettlemoyer, L. 2020. BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, 7871–7880.
  12. 12.Liu, Y.; Ott, M.; Goyal, N.; Du, J.; Joshi, M.; Chen, D.; Levy, O.; Lewis, M.; Zettlemoyer, L.; and Stoyanov, V. 2019. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692.
  13. 13.Lu, S.; Guo, D.; Ren, S.; Huang, J.; Svyatkovskiy, A.; Blanco, A.; Clement, C.; Drain, D.; Jiang, D.; Tang, D.; et al. 2021. CodeXGLUE: A Machine Learning Benchmark Dataset for Code Understanding and Generation. arXiv preprint arXiv:2102.04664.
  14. 14.Nguyen, A. T.; Nguyen, T. T.; and Nguyen, T. N. 2013. Lexical statistical machine translation for language migration. In Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering, 651–654.
  15. 15.Nguyen, A. T.; Nguyen, T. T.; and Nguyen, T. N. 2015. Divide-and-conquer approach for multi-phase statistical migration for source code (t). In 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE), 585–596. IEEE.
  16. 16.Papineni, K.; Roukos, S.; Ward, T.; and Zhu, W.-J. 2002. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting of the Association for Computational Linguistics, 311–318.
  17. 17.Puri, R.; Kung, D. S.; Janssen, G.; Zhang, W.; Domeniconi, G.; Zolotov, V.; Dolby, J.; Chen, J.; Choudhury, M.; Decker, L.; et al. 2021. Project CodeNet: A Large-Scale AI for Code Dataset for Learning a Diversity of Coding Tasks. arXiv preprint arXiv:2105.12655.
  18. 18.Rabinovich, M.; Stern, M.; and Klein, D. 2017. Abstract Syntax Networks for Code Generation and Semantic Parsing. In ACL (1).
  19. 19.Ren, S.; Guo, D.; Lu, S.; Zhou, L.; Liu, S.; Tang, D.; Sundaresan, N.; Zhou, M.; Blanco, A.; and Ma, S. 2020. Codebleu: a method for automatic evaluation of code synthesis. arXiv preprint arXiv:2009.10297.
  20. 20.Roziere, B.; Lachaux, M.-A.; Chanussot, L.; and Lample, G. 2020a. Unsupervised Translation of Programming Languages. In Larochelle, H.; Ranzato, M.; Hadsell, R.; Balcan, M. F.; and Lin, H., eds., Advances in Neural Information Processing Systems, volume 33, 20601–20611. Curran Associates, Inc.
  21. 21.Roziere, B.; Lachaux, M.-A.; Chanussot, L.; and Lample, G. 2020b. Unsupervised Translation of Programming Languages. In NeurIPS.
  22. 22.Roziere, B.; Lachaux, M.-A.; Szafraniec, M.; and Lample, G. 2021. DOBF: A Deobfuscation Pre-Training Objective for Programming Languages. arXiv preprint arXiv:2102.07492.
  23. 23.Vaswani, A.; Shazeer, N.; Parmar, N.; Uszkoreit, J.; Jones, L.; Gomez, A. N.; Kaiser, Ł.; and Polosukhin, I. 2017. Attention is all you need. In Advances in neural information processing systems, 5998–6008.
  24. 24.Yin, P.; and Neubig, G. 2017. A Syntactic Neural Model for General-Purpose Code Generation. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 440–450.
  25. 25.Zens, R.; Och, F. J.; and Ney, H. 2002. Phrase-based statistical machine translation. In Annual Conference on Artificial Intelligence, 18–32. Springer.

Citation

MLA
Zhu, M., et al. “Multilingual Code Snippets Training for Program Translation”. Proceedings of the AAAI Conference on Artificial Intelligence, vol. 36, no. 10, 2022, pp. 11783–90, https://doi.org/10.1609/AAAI.V36I10.21434.
APA
Zhu, M., Suresh, K., & Reddy, C. K. (2022). Multilingual Code Snippets Training for Program Translation. Proceedings of the AAAI Conference on Artificial Intelligence, 36(10), 11783–11790. https://doi.org/10.1609/AAAI.V36I10.21434
Chicago
Zhu, M., K. Suresh, and C. K. Reddy. 2022. “Multilingual Code Snippets Training for Program Translation”. Proceedings of the AAAI Conference on Artificial Intelligence 36 (10): 11783–90. https://doi.org/10.1609/AAAI.V36I10.21434.
Harvard
Zhu, M., Suresh, K. and Reddy, C.K. (2022) “Multilingual Code Snippets Training for Program Translation”, Proceedings of the AAAI Conference on Artificial Intelligence, 36(10), pp. 11783–11790. Available at: https://doi.org/10.1609/AAAI.V36I10.21434.
Vancouver
1. Zhu M, Suresh K, Reddy CK (2022) Multilingual Code Snippets Training for Program Translation. Proceedings of the AAAI Conference on Artificial Intelligence 36:11783–11790

BibTeX

@article{Zhu_2022, title={Multilingual Code Snippets Training for Program Translation}, volume={36}, ISSN={2159-5399}, url={http://dx.doi.org/10.1609/AAAI.V36I10.21434}, DOI={10.1609/aaai.v36i10.21434}, number={10}, journal={Proceedings of the AAAI Conference on Artificial Intelligence}, publisher={Association for the Advancement of Artificial Intelligence (AAAI)}, author={Zhu, Ming and Suresh, Karthik and Reddy, Chandan K}, year={2022}, month=June, pages={11783–11790} }
Metadata:Crossref

Access the Paper

This paper is available from its original source. Click below to access the PDF.

Open PDF