More Like this

1. From Pseudo-Code to Source Code: A Self-Supervised Search Approach

   Kulkarni, Adithya; Chakraborty, Mohna; Sium, Yonas Afewerki; Valluri, Sai Charishma; Le, Wei; Li, Qi (April 2025, ICLR 2025 Third Workshop on Deep Learning for Code)
2. Evaluating How Novices Utilize Debuggers and Code Execution to Understand Code

   https://doi.org/10.1145/3632620.3671126  

   Hassan, Mohammed; Zeng, Grace; Zilles, Craig (August 2024, ACM)

   Background: Previous work has shown that students can understand more complicated pieces of code through the use of common software development tools (code execution, debuggers) than they can without them. Objectives: Given that tools can enable novice programmers to understand more complex code, we believe that students should be explicitly taught to do so, to facilitate their plan acquisition and development as independent programmers. In order to do so, this paper seeks to understand: (1) the relative utility of these tools, (2) the thought process students use to choose a tool, and (3) the degree to which students can choose an appropriate tool to understand a given piece of code. Method: We used a mixed-methods approach. To explore the relative effectiveness of the tools, we used a randomized control trial study (𝑁 = 421) to observe student performance with each tool in understanding a range of different code snippets. To explore tool selection, we used a series of think-aloud interviews (𝑁 = 18) where students were presented with a range of code snippets to understand and were allowed to choose which tool they wanted to use. Findings: Overall, novices were more often successful comprehending code when provided with access to code execution, perhaps because it was easier to test a larger set of inputs than the debugger. As code complexity increased (as indicated by cyclomatic complexity), students become more successful with the debugger. We found that novices preferred code execution for simpler or familiar code, to quickly verify their understanding and used the debugger on more complex or unfamiliar code or when they were confused about a small subset of the code. High-performing novices were adept at switching between tools, alternating from a detail-oriented to a broader perspective of the code and vice versa, when necessary. Novices who were unsuccessful tended to be overconfident in their incorrect understanding or did not display a willingness to double check their answers using a debugger. Implications: We can likely teach novices to independently understand code they do not recognize by utilizing code execution and debuggers. Instructors should teach students to recognize when code is complex (e.g., large number of nested loops present), and to carefully step through these loops using debuggers. We should additionally teach students to be cautious to double check their understanding of the code and to self-assess whether they are familiar with the code. They can also be encouraged to strategically switch between execution and debuggers to manage cognitive load, thus maximizing their problem-solving capabilities. 

   more » « less
3. SPT-code: sequence-to-sequence pre-training for learning source code representations

   https://doi.org/10.1145/3510003.3510096  

   Niu, Changan; Li, Chuanyi; Ng, Vincent; Ge, Jidong; Huang, Liguo; Luo, Bin (May 2022, 2022 IEEE/ACM 44th International Conference on Software Engineering (ICSE))
4. OpenMolcas: From Source Code to Insight

   https://doi.org/10.1021/acs.jctc.9b00532  

   Fdez. Galván, Ignacio; Vacher, Morgane; Alavi, Ali; Angeli, Celestino; Aquilante, Francesco; Autschbach, Jochen; Bao, Jie J.; Bokarev, Sergey I.; Bogdanov, Nikolay A.; Carlson, Rebecca K.; et al (October 2019, Journal of Chemical Theory and Computation)
5. Optimization to the Rescue: Evading Binary Code Stylometry with Adversarial Use of Code Optimizations

   https://doi.org/10.1145/3465413.3488574  

   Jacobsen, Ben; Rahaman, Sazzadur; Debray, Saumya (November 2021, Proceedings of the 2021 Research on offensive and defensive techniques in the Context of Man At The End (MATE) Attacks)

   Kwon, Yonghwi; Banescu, Sebastian (Ed.)

   Recent work suggests that it may be possible to determine the author of a binary program simply by analyzing stylistic features preserved within it. As this poses a threat to the privacy of programmers who wish to distribute their work anonymously, we consider steps that can be taken to mislead such analysis. We begin by exploring the effect of compiler optimizations on the features used for stylistic analysis. Building on these findings, we propose a gray-box attack on a state-of-the-art classifier using compiler optimizations. Finally, we discuss our results, as well as implications for the field of binary stylometry. 

   more » « less