Mark’s research focuses on increasing programmers' productivity by automating various activities at different stages of the development lifecycle. In his research, Mark utilizes various techniques from software engineering, language design, program analysis, and machine learning to address specific issues that affect programmers when they design, debug, and test software.

Currently, Mark is working with his colleagues and collaborators on the following projects.

• AbStraction Search for Intuitive Software Testing (ASSIST)
  A fundamental question of testing is how to select a manageable subset of the input data for test cases without compromising the effectiveness of testing. Intuitive testing is a method for testers to exercise the product based on their intuition and experience, surmising probable errors without exhaustively exploring all inputs to applications. Intuition helps testers to form abstractions with correctly assign relevancy rankings to different facts, leading to more effective test cases that are built using
  these abstractions.
  
  We offer a novel solution for finding key abstractions automatically. ASSIST is a learning testing system that selects a small subset of test cases to enable testers to steer towards more challenging tests to find more bugs in applications in a smaller period of testing time. We have implemented ASSIST and applied it to a large-scale application at an insurance company. Our results showed that ASSIST identifies key abstractions that are in line with what experienced testers and developers learned about this application.
   
• MOdularization And reuse of Test Scrips (MOATS)
  A primary way to automatically test GUI-based APplications (GAPs) is by running test scripts that interact with GAPs by performing actions on their GUI objects. An extra effort that test engineers put in writing test scripts is paid off when these scripts are reused repeatedly on different GAPs. Unfortunately, test scripts depend heavily on the structures of GUIs, making it difficult for test engineers to reuse these scripts on different GAPs, thereby obliterating benefits of test automation.
  
  We offer novel programming abstractions with which testers can specify what to test instead of how to test GAPs. We implement these abstractions as annotations to Java language and its runtime, prove the soundness of the type system, and give our type checking algorithm. The results of our evaluation show that our solution is effective in practice in helping test engineers to produce modular test logic and reason about it, and prevent and eliminate errors in these scripts.
   
• Resolving databasE Deadlocks from Application-Centered Transactions (REDACT)
  REDACT addresses the fundamental problem of predicting and resolving database deadlocks in database-centric applications. Our approach unifies disparate applications that use the same databases in a novel and promising way: their asynchronously issued transactions become resource sharing requests, and these requests can be identified and acted upon before they are executed by the database. This integration of databases and applications that use them constitutes the core of the proposed scalable database deadlock resolution algorithm.
   
• Testing Applications with Data Anonymization (TaDa)
  Database-centric applications (DCAs) are common in enterprise computing, and they use nontrivial databases as part of their logic. Testing of DCAs is increasingly outsourced to testing centers in order to achieve lower cost and better quality. When releasing proprietary DCAs, its databases should also be made available to test engineers so that they can test using real data. However, since these databases contain sensitive information, they cannot be disclosed to anyone outside the organizations that own these DCAs. Currently, testing is performed with fake data that often leads to worse code coverage and fewer uncovered bugs, thereby reducing the quality of applications and obliterating benefits of test outsourcing.
  
  With TaDa, DCAs can be released to external testing organizations without disclosing sensitive information while retaining testing efficacy. We built a tool and applied it to nontrivial Java applications. Our results show that TaDa is effective and efficient at automatically anonymizing different databases, while preserving a higher level of test coverage.
   
• Creating and Evolving Software via Searching, Selecting and Synthesizing Relevant Source Code - The S³ architecture. (with NSF support CCF-0916139)
  Software developers rely on reusing source code snippets from existing libraries or applications to develop software features on time and within budget. The reality is such that most previously implemented features are embedded in billions of lines of scattered source code. State-of-the-art code search engines provide no guarantee that retrieved code snippets implement these features. Even if relevant code fragments are located, developers face rather complex task of selecting and moving these fragments into their applications. Finally, synthesizing new functionality by composing selected code fragments requires sophisticated reasoning about the behavior of these fragments and the consequent code. The result of this process is an overwhelming complexity, a steep learning curve, and a significant cost of building customized software.
  
  This research program proposes an integrated model for addressing fundamental problems of searching, selecting, and synthesizing (S3) source code. The S3 model relies on integrating program analysis and information retrieval to produce transformative models to automatically search, select, and synthesize relevant source code fragments. The S3 model will directly support new methodologies for software change and automated tools that assist programmers with various development, reuse and maintenance activities. Among the broader impacts the project includes collaboration with industry to transfer technology.