ChimpCheck: Property-based Testing for Android Apps via Fusing Scripting with Automated Generation.
Industrial practice for testing Android applications (apps) have largely been focused strictly on either automated test generation (e.g., random exercising, model-based/search-based techniques) or manual UI scripting (e.g., Android Espresso, Robotium). While test generation offer effective automated solutions for testing generic functionalities of an app, a test developer must still rely on manual scripting to get to corner cases that requires human knowledge of the app. For instance, testing valid login with a test account, asserting life-cycle properties of an app’s sub-system (e.g., mediaplayer). Existing tools on both fronts are rarely designed to integrate with one another, making the developer’s adhoc composition of the two techniques uneasy at best, error-prone at its worst. In this project, we aim to close this gap by developing a domain specific language and combinator library that enables a test developer to seamlessly create relevant test generators, by composing state-of-the-art test generation techniques with her own custom scripts, all in a single executable and human-readable specification language.
My Role: Lead Researcher / Lead Engineer
Collaborators: Bor-Yuh Evan Chang, Peilun Zhang
GitHub Project: https://github.com/cuplv/ChimpCheck
Fixr: Mining and Understanding Bug Fixes
The goals of the Fixr project is to develop a suite of program analysis, probabilistic inference, code synthesis, and social data mining tools that cooperatively and automatically infer high confidence repair specifications for app-framework protocol bugs. We aim to develop our approach to leverage the large and continuously-increasing enclave of applications that program against any given framework—crucially using the MUSE database itself to generate high-quality artifacts with which to populate it.
My Role: Participating Researcher
Project Site: http://plv.colorado.edu/projects/fixr/
Research Papers: [ESEM2017]
Big Glue: Glue Code Combinator Library for Heterogeneous Data Processing Pipelines
Developing large scale data processing pipelines is hard. Tough challenges awaits at every level of the engineering stack, from integration of tool-chains, optimizing for incrementality of processing, keeping track of provenance data, to customizing deployment strategies in the cloud. Our experiences in the Fixr project has taught us one important lesson: many of these engineering endeavors are boiler-plate and repeated across our program analysis pipelines. In this project, we explore distilling these similarities across these pipelines, and derive a front-end for developing such pipelines via a high-level type-safe declarative combinator library. This library enables developers to rapidly prototype data processing pipelines by only specifying their high-level dataflow structures, and automatically synthesizing the backend deployments that handles incrementality, provenance tracking, distributed deployments, and interactions with databases. “Data processors” facilitated by these pipelines are not limited to executing simple string manipulations, but any arbitrary data transformation task, from programming analysis to execution of build scripts, making this approach widely applicable to various big-data processing problems.
My Role: Lead Researcher
Research Papers: None yet, work in progress!
CoMingle: High-level Orchestration for Distributed Event-Driven Systems
CoMingle is a coorindation programming framework for orchestrating applications distributed over multiple mobile devices. Distributed computations involving multiple parties are specified as a single declarative program in a ensemble-centric manner, rather than in the traditional node-centric manner, where separate communicating code is written for each participating node. In all, CoMingle programs not only represent easy to read declarative specifications of decentralized ensembles, they are executable and provide an intuitive interface to your Android applications.
My Role: Lead Researcher / Lead Engineer
Collaborators: Iliano Cervesato, Ali Elgazar, Nabeeha Fatima
GitHub Project: https://github.com/sllam/comingle
Parallel Execution of Constraint Handling Rules
Constraint Handling Rules (CHR) is a declarative rule-based programming language originally designed for expressing constraint propagating solvers. In this project, we have developed an implementation of CHR that executes on multi-core systems, particularly in Haskell (GHC) as a combinator library built on top of Software Transactional Memory (STM). We have also explored applying Parallel CHR solutions to problems in distributed and concurrent programming, arguing its practically as a high-level parallel programming abstraction that has strong relations with Join Calculus, Linear Logic and Petri-nets.
My Role: Participating Phd Student
Collaborator: Martin Sulzmann