Research ideas
Some ideas in this page are outdated. If you are currently a student at USF, you can contact me to discuss the active research projects and ideas I am involved with.
Here are some research ideas I've been looking at. I am looking for students to work with me on any of these, so if any of these ideas interests you, feel free to reach out to me.
- Better constraint logic programming languages for writing fuzzers
- Better in this context means more ergonomic. Exploring ways to decouple search strategies and generative models to make experimenting on black-box language fuzzers easier.
- Faster automated test generation/testing (fuzzing)
- there are several
threads of research I am interested in this space:
- Pruning useless tests early on.
- Pruning the system under test to speed up testing.
- Reducing the runtime overhead of additional tests during fuzzing.
- Automatic verification of programming assignments
- to allow giving better feedback to students, and replacing test suites with something comprehensive.
- Automatic feedback on programming assignments
- this involves using static & dynamic analysis, invariant discovery, etc. Also, pointing out likely causes of failing tests would fall into this category.
- Dynamically discovering static analysis stubs
- this is similar to finding the Dafny function signatures dynamically to help going around code that is difficult to analyze. This is also useful for generating initial FFI bindings.
- Semantic code differencing
- using dynamic invariants.
General research areas of interest
These are general research areas, subfields, and problems I am interested in. If you have any ideas in these areas, or curious to chat about them, just drop by or send me an email.
- Static program analysis
- Abstract interpretation, debugging static analyzers, transferring information between different analysis levels, automatically optimizing abstract interpreters (potentially using Datalog).
- Pointer analysis, set constraint solving
- optimizing set constraint solvers, off-loading work to GPUs, designing hardware accelerators for these solvers.
- Translating programs to Rust
- there are several threads here I am interested in:
- Improving C to Rust translation
- designing interactive methods to translate the program with programmers help, better pointer analyses.
- Translating Go to Rust
- reasoning about concurrency properties and channels, getting rid of the GC as much as possible.
- Programming language-based guarantees in IoT systems
- these systems deal
with lots of state, networking, and work on low-energy embedded
systems. Techniques from PL can help give safety guarantees in this domain.
- Also, low-overhead runtime verification would be a useful tool in this space.
- Transferring ideas between symbolic execution and program synthesis
- analyzing solver-based program synthesis from the lens of symbolic execution.
- Profile-guided optimizations
- incremental link-time optimization (reusing artifacts between program versions),
- Machine learning+program analysis
- Offloading decision problems in program analysis (variable packing, choosing analysis sensitivity, etc.) to reinforcement learning systems.
- Applying PL techniques to non-PL systems
- games, version control systems, etc.