Finding and combining hidden data in modern data lakes currently relies on black-box AI tools or trial-and-error, offering no guarantees of correctness. This project introduces SQLP-DL, a brand-new, formal query language. Solving this transforms data discovery from an unpredictable guessing game into a reliable science, allowing programmers to safely combine, optimize, and reuse data pipelines without errors.
Tags: 2nd year +, 3rd year +, Data Structures, Programming Languages, Compilers
Data lakes contain massive amounts of structured tables and unstructured images. Currently, database systems cannot connect them automatically; a table of store products and a folder of product images remain completely isolated. This research bridges that gap using vision-language AI models to map text, data columns, and images into a shared space. Solving this unlocks "dark data," allowing organizations to fully search, analyze, and use all their visual and text data together for the first time.
Tags: 2nd year +, 3rd year +, Linear Algebra, Data Structures, Basic Programming
Recent experiments have revealed surprisingly large performance variation across repeated executions of some applications, even after taking standard benchmarking precautions. One possible explanation is that ASLR produces memory layouts with significantly different performance characteristics. If so, an important challenge is determining how these layouts differ and identifying the memory-layout properties responsible for the observed performance changes.
A possible research direction is to develop techniques and tools for detecting ASLR-induced performance variation, comparing memory layouts across executions, and identifying the characteristics that distinguish faster and slower runs. Such a tool could potentially build upon HeapLENS and leverage AI-assisted analysis to help explain observed performance differences.
Tags: C/C++, Data Structures, Multithreading, Memory Management, Operating Systems, Systems, 2nd Year +
Professor T. Brown recently developed a system called HeapLENS to help researchers automatically examine the memory layout of multithreaded applications. HeapLENS is specifically designed to produce compact, high-quality, curated output suitable for AI-driven analysis. While HeapLENS output can already enable AI agents to improve application memory layouts by a significant margin, the current workflow invokes HeapLENS only once and uses its output only once. A natural research direction is therefore to adapt HeapLENS to support repeated interaction with an AI agent, enabling an iterative optimization cycle in which incremental changes can be proposed, evaluated, and refined.
Tags: C/C++, Data Structures, Multithreading, Memory Management, Operating Systems, Systems, Artificial Intelligence, 2nd Year +
Professor T. Brown and collaborators recently designed a concurrent version of the van Emde Boas tree that incorporates a number of novel space optimizations and can outperform other state-of-the-art concurrent ordered sets by a large margin. However, this data structure relies on hardware transactional memory (HTM) for synchronization. The goal of this project is to extend this work to universally available synchronization mechanisms for systems without HTM support, with optimistic concurrency control (OCC) being one natural direction.
Tags: C/C++, Data Structures, Multithreading, Systems, 2nd Year +
For secure multiparty computation (MPC), our goal is for parties 1 to n to securely compute f(x1, …, xn) where xi is the private input of party i. Our security condition is for the messages each party sends and receives during the computation of f to reveal no more information than its input and output. This allows the parties to collaboratively compute a function over their private inputs while maintaining privacy.
Many non-private implementations of algorithms often access data structures at indices determined at runtime. Since such indices are determined by the input, revealing such indices would compromise privacy according to our definition. While there are asymptotically efficient solutions to adapt these algorithms to the MPC model, these solutions use generic constructions, and the constant factors make using them impractical.
Tags: Data Structures, Algorithms, Security, All Years
When a compiler crashes, the program that triggered it is often thousands of lines long, yet almost none of them matter to the failure. "Program reduction" tools automatically shrink such inputs to a tiny reproducing example by repeatedly deleting pieces and re-testing. The major algorithms (Delta Debugging, Hierarchical Delta Debugging, Perses, ProbDD) are closely related and even reuse one another, but each is its own separate program, so they are hard to compare head-to-head or mix and match. This project builds a clean open-source framework where the candidate-generation strategy and the inner reduction algorithm are each a swappable plug-in. With every algorithm running on one shared engine, they can be compared on equal footing and recombined in new ways
Tags: Compilers, Python, Data Structures, Rust, 2nd Year +, Experienced 1st Years