I currently work on Software Engineering and Programming languages. I am especially interested in developing techniques and tools that will increase programmer productivity and decrease programmer mistakes (bugs). I strongly believe that most of the time to develop a software is either spent as the time that developer actually programs it, or as the time developer debugs it. Thus, if we can reduce this time, than the developer would have more time to create more software and average software cost would reduce. I am currently advised by Michael Ernst and Yuriy Brun. Before his untimely passing, I had the opportunity to work with and be advised by David Notkin. As an undergraduate, I worked on Software Verification and Formal Methods, especially proving the correctness of concurrent algorithms and programs using automated proving tools and techniques. I was advised by Serdar Taşıran.

On this page, I list some of my projects in reverse chronological order. For personal software please see: Software

Automating Version Control and Improving Historical Analyses

Spring’14–Present

Development history is useful for various software engineering tasks, such as finding the cause of regression bugs. Unfortunately, manually managed development histories are incomplete and coarse-grained. I designed a technique that automatically records a complete and fine-grained development history. I showed that this fine-grained history improves the output of the existing historical analyses — analyses that use the development history — and makes it possible to implement new historical analyses.
Project Webpage: https://bitbucket.org/kivancmuslu/chronos
Collaborators: Luke Swart, Yuriy Brun, and Michael D. Ernst
Related Publications: Simplifying Development History Information Retrieval via Multi-Grained Views

Continuous Data Testing

Spring’13–Present

Data entry errors cost the world economy billions of dollars. I found that extending testing to data in databases could eliminate 60% of data entry errors.
Collaborators: Yuriy Brun and Alexandra Meliou
Related Publications: Preventing Data Errors with Continuous Testing and Data Debugging with Continuous Testing

Realtime Code Analysis through IDE-Managed Code Copies

Winter’12–Present

Continuous analyses automatically compute an up-to-date result without requiring the developer to execute an acting other than editing the source code. These analyses can greatly improve developer productivity, but they are hard to build. I identified two major challenges to building such analyses: currency — how fast an analysis gets access to developer edits — and isolation — ensuring that an ongoing analysis and concurrent developer edits do not conflict with each other. I built Solstice, a framework that makes the implementation of continuous analyses easier by letting them exclusively own a copy codebase and run on it isolated from concurrent developer edits.
Project Webpage: https://bitbucket.org/kivancmuslu/solstice
Collaborators: Yuriy Brun, Michael D. Ernst, and David Notkin
Related Publications: Reducing Feedback Delay of Software Development Tools via Continuous Analyses (in press) and Making Offline Analyses Continuous

Speculative Analysis of IDE Recommendations

Autumn’10–Autumn’12

IDEs recommend multiple fixes for each compilation error, but it is difficult for programmers to mentally evaluate them and choose the best one. I showed that computing the effects of these fixes on a program’s compilation error can guide the developer to more quickly fix such errors. I built Quick Fix Scout, an Eclipse plug-in to speculatively evaluate the effects of Eclipse quick fixes and recommend the best fixes for compilation errors.
Project Webpage: http://quick-fix-scout.googlecode.com
Collaborators: Yuriy Brun, Reid Holmes, Michael D. Ernst, and David Notkin
Related Publications: Speculative Analysis of Integrated Development Environment Recommendations and Improving IDE Recommendations by Considering Global Implications of Existing Recommendations

Dependent Tests

Spring’11–Present

Data dependencies between unit tests can mask bugs in the program and in the test suite, and lead to inconsistent documentation. I implemented a framework that runs tests in isolation so that dependencies between tests will not affect test suite results. This approach could have detected a bug in Apache Commons CLI 120 revisions earlier than the developers fixed it.
Collaborators: Wing Lam, Bilge Soran, Darioush Jalali, Sai Zhang, Jochen Wuttke, Michael D. Ernst, and David Notkin
Related Publications: Empirically Revisiting the Test Independence Assumption and Finding Bugs by Isolating Unit Tests

Pluggable Type Checking for Java Naming Conventions

Autumn’10–Spring’11

Java uses different naming conventions to represent the same class in the source code, class files, and byte code. For software that translates between naming conventions, using the correct convention is error-prone. I built a type system and a type-checker that detects misuse of naming conventions. Using the type-checker, I found 14 bugs in JDK 7, and 14 more bugs in other open-source software.
Collaborators: Werner Dietl and Michael D. Ernst
Related Publications: Building and Using Pluggable Type-Checkers

Measuring the Effectiveness of a Concurrency Coverage Metric

Summer’08

Sequential code coverage metrics are not correlated well with concurrency bugs. I showed that Keremoğlu’s concurrency coverage metric based on conflicting read-write accesses is better correlated with detecting bugs, compared to the Definition-Use and Method Pairs metrics.
Collaborators: Erkan Keremoğlu and Serdar Taşıran
Related Publications: Location Pairs: A Test Coverage Metric for Shared-memory Concurrent Programs

Tressa: Asserts in the Future

Spring’09

It is difficult to detect atomicity violations in optimistic concurrent software using assert statements. I showed that Sezgin’s tressa theory is effective for detecting such violations.
Collaborators: Ali Sezgin, Serdar Taşıran, and Shaz Qadeer
Related Publications: Run-time Verification of Optimistic Concurrency