More Like this

1. 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
2. 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)
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. A Code Transformation to Improve the Efficiency of OpenCL Code on FPGA through Pipes

   https://doi.org/10.1145/3587135.3592210  

   Zarch, Mostafa Eghbali; Becchi, Michela (May 2023, CF '23: Proceedings of the 20th ACM International Conference on Computing Frontiers)

   Over the past few years, there has been an increased interest in using FPGAs alongside CPUs and GPUs in high-performance computing systems and data centers. This trend has led to a push toward the use of high-level programming models and libraries, such as OpenCL, both to lower the barriers to the adoption of FPGAs by programmers unfamiliar with hardware description languages, and to allow to deploy a single code on different devices seamlessly. Today, both Intel and Xilinx offer toolchains to compile OpenCL code onto FPGA. However, using OpenCL on FPGAs is complicated by performance portability issues, since different devices have fundamental differences in architecture and nature of hardware parallelism they offer. Hence, platform-specific optimizations are crucial to achieving good performance across devices. In this paper, we propose a code transformation to improve the performance of OpenCL codes running on FPGA. The proposed method uses pipes to separate the memory accesses and core computation within OpenCL kernels. We analyze the benefits of the approach as well as the restrictions to its applicability. Using OpenCL applications from popular benchmark suites, we show that this code transformation can result in higher utilization of the global memory bandwidth available and increased instruction concurrency, thus improving the overall throughput of OpenCL kernels at the cost of a modest resource utilization overhead. Further concurrency can be achieved by using multiple memory and compute kernels. 

   more » « less