Programming Languages and Compilers Commons^™

A Novel Entropy Based Maintainability Measurement Algorithm For Java Source Code., Remi M. Yusuf Mr, Md Shadab Mashuk, Julian Bass

Communications of the IIMA

Software metrics play a central role in assessing and managing the quality of software systems providing quantitative insights into attributes such as complexity, reliability, rigidity, modifiability and maintainability. Among these, maintainability is particularly critical, as it directly influences the ease of system evolution, long-term sustainability, and overall cost effectiveness. Despite the widespread use of metric-based maintainability measurement algorithms, capturing a value that reflects the maintainability situation of software source code remains a challenging task, especially in the presence of design deficiencies such as code smells. To measure changes in maintainability, this study experimentaly characterises the relationship between code smells and …

Leveraging Deep Learning Recurrence And Attention Mechanisms For Flood Forecasting And Assessment, Elnaz Heidari

All Dissertations

Predicting how much water will flow in rivers and streams is important for managing floods, water supply, and the environment. Traditionally, government agencies have used complex models, such as the National Water Model (NWM), which simulate how much water moves through landscapes using physical laws and real-world data. However, recent advances in Artificial Intelligence (AI) have enabled new ways to make these predictions. This research explored whether AI-based models could predict river discharge more accurately. These AI models learn patterns from past data instead of relying only on physical rules. To find out how well they work, the AI models …

The Security Of Llm-Generated Code, Christopher Brian Gonzalez Ayala

Student Theses

The rapid adoption of Large Language Models (LLMs) in software development has transformed coding practices by enabling automated code generation, completion, and optimization. Despite these advantages, concerns persist regarding the security and reliability of LLM-generated code. This study presents a comprehensive evaluation of both the functional correctness and security of code produced by three prominent LLMs as of early 2026. A total of 4,800 code snippets were generated using 100 security-focused programming prompts derived from the OWASP Top 10:2025, translated across eight natural languages and two phrasing styles (literal and natural developer-oriented prompts). To assess performance, a multi-stage experimental framework …

Weavecc: Symbolically-Guided Joint Exploration Of Inputs And Schedules For Concurrency Bug Detection, William Philip Dinauer

Dartmouth College Master’s Theses

Concurrent programs introduce a class of bugs that depend jointly on both program inputs and thread schedules. Exposing these bugs requires simultaneously reasoning about which code paths are reachable and which thread interleavings are possible. At the same time, many existing tools handle the problem insufficiently. Race detectors observe only the interleavings that the OS happens to produce. Fuzzers explore inputs without controlling schedules. Tools that address both dimensions together exist, but are built on interpretation-based symbolic executors that incur considerable overhead.

We present WeaveCC, a practical concurrency testing tool for C/C++ programs that jointly explores inputs and thread schedules. …

Maddenlite, Sergio Pena

Presentations - 2026

Problem •“What If” scenarios impossible to test accurately •Commercial games rely on arcade physics •Spreadsheets lack visual engagement

Motivation •Passion for football analytics •Desire to simulate cross-era matchups •Apply math models to real-world sports data

Solution •Python based simulation engine using historical play-by-play data •Simulates outcomes based on probability

Spinlock Game Engine, Shane Misley

Posters - 2026

Modern game engines prioritize developer convenience at the cost of performance and transparency. Large frameworks like Unity and Unreal Engine abstract away implementation details, which simplifies development but introduces computational overhead—often 40-50% of CPU and memory usage goes to engine infrastructure rather than the actual game. For developers targeting low-end hardware, older systems, or performance-critical applications, this overhead becomes prohibitive. The Spinlock Engine addresses this problem by adopting a "close-to-the-metal" philosophy, stripping away unnecessary abstraction layers to deliver raw speed and predictable behavior. Built in C++ with SDL3 and Raylib, Spinlock prioritizes memory efficiency, CPU optimization, and developer transparency—allowing you …

A Virtual-Reality-Based Dental Simulator For Endodontics With Automated Formative Feedback, Yousef Salah Abo El Ela

Theses and Dissertations

Advancements in virtual reality (VR) and haptic technology are transforming the landscape of medical and dental education, offering new avenues for safe, immersive, and repeatable training experiences. Within dentistry, endodontics presents unique challenges for preclinical education due to anatomical complexity, limited access to extracted teeth, ethical concerns, and the shortcomings of conventional plastic models. Despite endodontics specific plastic teeth being available, they fall short of replicating the hardness of real extracted teeth, are relatively costly compared to generic plastic teeth, and are ultimately a disposable item which makes them inadequate as a sustainable long-term solution. Extracted teeth do a much …

Do Developers Read Type Information? An Eye-Tracking Study On Typescript, Samuel W. Flint, Robert Dyer, Bonita Sharif

Research & Publications

Statically-annotated types have been shown to aid developers in a number of programming tasks, and this benefit holds true even when static type checking is not used. It is hypothesized that this is because developers use type annotations as in-code documentation. In this study, we aim to provide evidence that developers use type annotations as in-code documentation. Understanding this hypothesized use will help to understand how, and in what contexts, developers use type information; additionally, it may help to design better development tools and inform educational decisions. To provide this evidence, we conduct an eye tracking study with 26 undergraduate …

A Decade Of Programming Languages: Trends In Popularity And Influence, Jonathan C. Erb

Williams Honors College, Honors Research Projects

Programming languages play a central role in open-source software ecosystems, yet their adoption, visibility, and influence shift over time as technologies, developer communities, and industry practices evolve. The study aims to investigate long-term trends in programming-language usage on GitHub from 2014 through 2024, focusing on ten major languages that represent diverse domains and ecosystems. Using repository metadata, engagement metrics such as stars and forks, and language-level code statistics measured with cloc, the analysis will examine changes in repository creation, code contribution volume, and popularity. Since popularity remains an unsettled and multidimensional concept, part of this research involves determining how it …

Automatic Generation Of Introductory Programming Exercises With Large Language Models, Nguyen Binh Duong Ta, Hua Gia Phuc Nguyen, Gottipati Swapna

Research Collection School Of Computing and Information Systems

Despite recent advances in code generation made possible by large language models (LLMs), programming is still an essential skill that computing students need to master now and in the foreseeable future. In learning programming, frequent practices with exercises set at an appropriate difficulty and knowledge level is of crucial importance for students. However, it’s not a trivial task for instructors to create many good quality exercises customized for each student. Programming problems found on Internet sources such as LeetCode are mostly too challenging for novice programmers with no prior coding knowledge. Recent work in AI-enabled education has been leveraging LLMs …

Llm-Driven Weekly Newsletter To Assess Open Source Software Project Github Health, Christian Novalski, Christopher Chavez, Ghalian Fayyadh, Kostadin Damevski

UROP Posters

Open Source Software (OSS) projects increasingly depend on a diverse set of contributors, including episodic participants who contribute intermittently. Episodic contributors represent a large portion of OSS communities, yet projects often struggle to retain them, leading to decreased project health and continuity. While dashboards and real-time communication tools support continuously active contributors, they often fail to serve the unique needs of episodic participants, who may struggle to remain informed and re-engage with project activity after periods of absence. In this study, we examine the effect of a weekly, email-based newsletter intervention designed to improve awareness and engagement among episodic OSS …

Backdoorllm: A Comprehensive Benchmark For Backdoor Attacks And Defenses On Large Language Models, Yige Li, Hanxun Huang, Yunhan Zhao, Xingjun Ma, Jun Sun

Research Collection School Of Computing and Information Systems

Generative large language models (LLMs) have achieved state-of-the-art results on a wide range of tasks, yet they remain susceptible to backdoor attacks: carefully crafted triggers in the input can manipulate the model to produce adversaryspecified outputs. While prior research has predominantly focused on backdoor risks in vision and classification settings, the vulnerability of LLMs in open-ended text generation remains underexplored. To fill this gap, we introduce BackdoorLLM1 , the first comprehensive benchmark for systematically evaluating backdoor threats in text-generation LLMs. BackdoorLLM provides: (i) a unified repository of benchmarks with a standardized training and evaluation pipeline; (ii) a diverse suite of …

Speculative Automated Refactoring Of Imperative Deep Learning Programs To Graph Execution, Raffi Khatchadourian Ph.D., Tatiana Castro Vélez, Mehdi Bagherzadeh, Nan Jia, Anita Raja

Publications and Research

Efficiency is essential to support ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code---supporting symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, imperative DL frameworks encouraging eager execution have emerged but at the expense of run-time performance. Though hybrid approaches aim for the "best of both worlds," using them effectively requires subtle considerations. Our key insight is that, while DL programs typically execute sequentially, hybridizing imperative DL code resembles parallelizing sequential code in traditional systems. Inspired by this, we …

Speculative Automated Refactoring Of Imperative Deep Learning Programs To Graph Execution, Raffi Khatchadourian Ph.D., Tatiana Castro Vélez, Mehdi Bagherzadeh, Nan Jia, Anita Raja

Publications and Research

Efficiency is essential to support ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code---supporting symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, imperative DL frameworks encouraging eager execution have emerged but at the expense of run-time performance. Though hybrid approaches aim for the "best of both worlds," using them effectively requires subtle considerations. Our key insight is that, while DL programs typically execute sequentially, hybridizing imperative DL code resembles parallelizing sequential code in traditional systems. Inspired by this, we …

Speculative Automated Refactoring Of Imperative Deep Learning Programs To Graph Execution, Raffi T. Khatchadourian Ph.D., Tatiana Castro Vélez, Mehdi Bagherzadeh, Nan Jia, Anita Raja

Publications and Research

Efficiency is essential to support ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code---supporting symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, imperative DL frameworks encouraging eager execution have emerged but at the expense of run-time performance. Though hybrid approaches aim for the "best of both worlds," using them effectively requires subtle considerations. Our key insight is that, while DL programs typically execute sequentially, hybridizing imperative DL code resembles parallelizing sequential code in traditional systems. Inspired by this, we …

Envisioning Future Interactive Web Development: Editing Webpage With Natural Language, Truong Hai Dang, Jingyu Xiao, Yintong Huo

Research Collection School Of Computing and Information Systems

The evolution of web applications relies on iterative code modifications, a process that is traditionally manual and time-consuming. While Large Language Models (LLMs) can generate UI code, their ability to edit existing code from new design requirements (e.g., ”center the logo”) remains a challenge. This is largely due to the absence of large-scale, high-quality tuning data to align model performance with human expectations. In this paper, we introduce a novel, automated data generation pipeline that uses LLMs to synthesize a high-quality fine-tuning dataset for web editing, named Instruct4Edit. Our approach generates diverse instructions, applies the corresponding code modifications, and performs …

Exploring Parameter-Efficient Fine-Tuning Techniques For Code Generation With Large Language Models, Martin Weyssow, Xin Zhou, Kisub Kim, David Lo, Houari A. Sahraoui

Research Collection School Of Computing and Information Systems

Large language models (LLMs) demonstrate impressive capabilities to generate accurate code snippets given natural language intents in a zero-shot manner, i.e., without the need for specific fine-tuning. While prior studies have highlighted the advantages of fine-tuning LLMs, this process incurs high computational costs, making it impractical in resource-scarce environments, particularly for models with billions of parameters. To address these challenges, previous research explored in-context learning (ICL) and retrieval-augmented generation (RAG) as strategies to guide the LLM generative process with task-specific prompt examples. However, ICL and RAG introduce inconveniences, such as the need for designing contextually relevant prompts and the absence …

Evaluating And Mitigating Linguistic Discrimination In Large Language Models: Perspectives On Safety Equity And Knowledge Equity, Guoliang Dong, Haoyu Wang, Jun Sun, Xinyu Wang

Research Collection School Of Computing and Information Systems

By training on text in various languages, large language models (LLMs) typically possess multilingual support and demonstrate remarkable capabilities in solving tasks described in different languages. However, LLMs can exhibit linguistic discrimination due to the uneven distribution of training data across languages. That is, LLMs are hard to keep the consistency of responses when faced with the same task but depicted in different languages. In this study, we first explore the consistency in the LLMs’ outputs responding to queries in various languages from two aspects: safety and quality. We conduct this analysis with two datasets (AdvBench and NQ) based on …

Leveraging Reviewer Experience In Code Review Comment Generation, Hong Yi Lin, Patanamon Thongtanunam, Christoph Treude, Michael W. Godfrey, Chunhua Liu, Wachiraphan Charoenwet

Research Collection School Of Computing and Information Systems

Modern code review is a ubiquitous software quality assurance process aimed at identifying and resolving potential issues (e.g., functional, evolvability) within newly written code. Despite its effectiveness, the process demands large amounts of effort from the human reviewers involved. To help alleviate this workload, researchers have trained various deep learning based language models to imitate human reviewers in providing natural language code reviews for submitted code. Formally, this automation task is known as code review comment generation. Prior work has demonstrated improvements in code review comment generation by leveraging machine learning techniques and neural models, such as transfer learning and …

Crow: Eliminating Backdoors From Large Language Models Via Internal Consistency Regularization, Nay Myat Min, Long H. Pham, Yige Li, Jun Sun

Research Collection School Of Computing and Information Systems

Large Language Models (LLMs) are vulnerable to backdoor attacks that manipulate outputs via hidden triggers. Existing defense methods—designed for vision/text classification tasks—fail for text generation. We propose Internal Consistency Regularization (CROW), a defense leveraging the observation that backdoored models exhibit unstable layer-wise hidden representations when triggered, while clean models show smooth transitions. CROW enforces consistency across layers via adversarial perturbations and regularization during finetuning, neutralizing backdoors without requiring clean reference models or trigger knowledge—only a small clean dataset. Experiments across Llama-2 (7B, 13B), CodeLlama (7B, 13B), and Mistral-7B demonstrate CROW’s effectiveness: it achieves significant reductions in attack success rates across …

Llm-Based Multi-Agent Systems For Software Engineering: Literature Review, Vision And The Road Ahead, Junda He, Christoph Treude, David Lo

Research Collection School Of Computing and Information Systems

Integrating Large Language Models (LLMs) into autonomous agents marks a significant shift in the research landscape by offering cognitive abilities that are competitive with human planning and reasoning. This paper explores the transformative potential of integrating Large Language Models into Multi-Agent (LMA) systems for addressing complex challenges in software engineering (SE). By leveraging the collaborative and specialized abilities of multiple agents, LMA systems enable autonomous problem-solving, improve robustness, and provide scalable solutions for managing the complexity of real-world software projects. In this paper, we conduct a systematic review of recent primary studies to map the current landscape of LMA applications …

Rattler Python, Samer Jabor

Systems Manuals - 2026

The Rattler Python project is an interactive game-based learning system that intends to teach the basic concepts of Python programming through guided instruction, gameplay challenges, and review-based assessments. The document contains a proposal for this system consisting of problem definition, background research, existing solutions, and the proposed product, together with the system scope, assumptions, and the organization of the remainder of this document.

Reaccept: Automated Co-Evolution Of Production And Test Code Based On Dynamic Validation And Large Language Models, Jianlei Chi, Xiaotian Wang, Yuhan Huang, Lechen Yu, Di Cui, Jianguo Sun, Jun Sun

Research Collection School Of Computing and Information Systems

Synchronizing production and test code, known as PT co-evolution, is critical for software quality. Given the significant manual effort involved, researchers have tried automating PT co-evolution using predefined heuristics and machine learning models. However, existing solutions are still incomplete. Most approaches only detect and flag obsolete test cases, leaving developers to manually update them. Meanwhile, existing solutions may suffer from low accuracy, especially when applied to real-world software projects. In this paper, we propose ReAccept, a novel approach leveraging large language models (LLMs), retrievalaugmented generation (RAG), and dynamic validation to fully automate PT co-evolution with high accuracy. ReAccept employs an …

Efficient And Green Large Language Models For Software Engineering: Literature Review, Vision, And The Road Ahead, Jieke Shi, Zhou Yang, David Lo

Research Collection School Of Computing and Information Systems

Large Language Models (LLMs) have recently shown remarkable capabilities in various software engineering tasks, spurring the rapid growth of the Large Language Models for Software Engineering (LLM4SE) area. However, limited attention has been paid to developing efficient LLM4SE techniques that demand minimal computational cost, time, and memory resources, as well as green LLM4SE solutions that reduce energy consumption, water usage, and carbon emissions. This article aims to redirect the focus of the research community toward the efficiency and greenness of LLM4SE, while also sharing potential research directions to achieve this goal. It commences with a brief overview of the significance …

Hotlangbench, A Tiny Benchmark Suite For Higher-Order Statically Typed Languages, Konstantin Laufer

Computer Science: Faculty Publications and Other Works

This work in progress aims to compare various HOT (higher-order and statically typed, a term coined by Phil Wadler) through reproducible course-grained, wall-time benchmarks. Our overall goals include simplicity, agility, and reproducibility.

There is currently only one benchmark, but it brings out substantial performance differences among the various languages and platforms. It uses function composition and other higher-order constructs to build a pipeline of transformations, along with a brute-force iteration that is computationally expensive for input files specifying large ranges as function domains. We currently include versions in Modern C++, C#, Go, Haskell, Kotlin, Modern (stream-based) Java (24), OCaml, Scala …

Hybridize Functions: A Tool For Automatically Refactoring Imperative Deep Learning Programs To Graph Execution, Raffi Khatchadourian, Tatiana Castro Vélez, Mehdi Bagherzadeh, Nan Jia, Anita Raja

Publications and Research

Efficiency is essential to support responsiveness w.r.t. ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code—supporting symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, imperative DL frameworks encouraging eager execution have emerged but at the expense of run-time performance. Though hybrid approaches aim for the “best of both worlds,” using them effectively requires subtle considerations to make code amenable to safe, accurate, and efficient graph execution—avoiding performance bottlenecks and semantically inequivalent results. We discuss the engineering aspects of a …

Hybridize Functions: A Tool For Automatically Refactoring Imperative Deep Learning Programs To Graph Execution, Raffi Khatchadourian, Tatiana Castro Vélez, Mehdi Bagherzadeh, Nan Jia, Anita Raja

Publications and Research

Efficiency is essential to support responsiveness w.r.t. ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code—supporting symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, imperative DL frameworks encouraging eager execution have emerged but at the expense of run-time performance. Though hybrid approaches aim for the “best of both worlds,” using them effectively requires subtle considerations to make code amenable to safe, accurate, and efficient graph execution—avoiding performance bottlenecks and semantically inequivalent results. We discuss the engineering aspects of a …

Hybridize Functions: A Tool For Automatically Refactoring Imperative Deep Learning Programs To Graph Execution, Raffi Khatchadourian, Tatiana Castro Vélez, Mehdi Bagherzadeh, Nan Jia, Anita Raja

Publications and Research

Efficiency is essential to support responsiveness w.r.t. ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code—supporting symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, imperative DL frameworks encouraging eager execution have emerged but at the expense of run-time performance. Though hybrid approaches aim for the "best of both worlds," using them effectively requires subtle considerations to make code amenable to safe, accurate, and efficient graph execution—avoiding performance bottlenecks and semantically inequivalent results. We discuss the engineering aspects of a …

Tailoring Transformer-Based Deep Learning For Code Generation And Translation, Imam Nur Bani Yusuf

Dissertations and Theses Collection (Open Access)

Software is increasingly pervasive in modern society, making the effective translation of human intent into code essential. Novice programmers often struggle with domain-specific code due to limited background knowledge, while experienced developers face challenges in maintaining evolving largescale codebases. Traditional pattern-based approaches address these issues, but such approaches are task-specific and require significant adaptation for different tasks. Transformer-based models offer a more flexible alternative, as the same architecture can be tailored for diverse programming tasks.

This dissertation investigates how Transformer-based models can be customized for various code generation and translation tasks. First, it introduces Transformer-based approaches that assist end-users with …

Intention Is All You Need: Refining Your Code From Your Intention, Qi Guo, Xiaofei Xie, Shangqing Liu, Ming Hu, Xiaohong Li, Lei Bu

Research Collection School Of Computing and Information Systems

Code refinement aims to enhance existing code by addressing issues, refactoring, and optimizing to improve quality and meet specific requirements. As software projects scale in size and complexity, the traditional iterative exchange between reviewers and developers becomes increasingly burdensome. While recent deep learning techniques have been explored to accelerate this process, their performance remains limited, primarily due to challenges in accurately understanding reviewers’ intents. This paper proposes an intention-based code refinement technique that enhances the conventional comment-to-code process by explicitly extracting reviewer intentions from the comments. Our approach consists of two key phases: Intention Extraction and Intention Guided Revision Generation. …