Jiasi Shen

Jiasi Shen Photo
PhD Candidate, MIT EECS & CSAIL
News
More news...

I am a PhD student at MIT advised by professor Martin Rinard. I received my bachelor's degree in Computer Science from Peking University.

My research interests are in programming languages and software engineering. I am interested in making programs easier to write, run, and understand. I have been developing techniques to infer and regenerate programs.

Selected Papers

  • Active Learning for Software Engineering
    José Cambronero, Thurston Dang, Nikos Vasilakis, Jiasi Shen, Jerry Wu, Martin Rinard
    Onward! 2019: Proceedings of the 2019 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software

    Software applications have grown increasingly complex to deliver the features desired by users. Software modularity has been used as a way to mitigate the costs of developing such complex software. Active learning-based program inference provides an elegant framework that exploits this modularity to tackle development correctness, performance and cost in large applications. Inferred programs can be used for many purposes, including generation of secure code, code re-use through automatic encapsulation, adaptation to new platforms or languages, and optimization. We show through detailed examples how our approach can infer three modules in a representative application. Finally, we outline the broader paradigm and open research questions.

    Paper (pdf)
  • Characterizing Developer Use of Automatically Generated Patches
    José Cambronero, Jiasi Shen, Jürgen Cito, Elena Glassman, Martin Rinard
    VL/HCC 2019: IEEE Symposium on Visual Languages and Human-Centric Computing, short paper

    We present a study that characterizes the way developers use automatically generated patches when fixing software defects. Our study tasked two groups of developers with repairing defects in C programs. Both groups were provided with the defective line of code. One was also provided with five automatically generated and validated patches, all of which modified the defective line of code, and one of which was correct. Contrary to our initial expectations, the group with access to the generated patches did not produce more correct patches and did not produce patches in less time. We characterize the main behaviors observed in experimental subjects: a focus on understanding the defect and the relationship of the patches to the original source code. Based on this characterization, we highlight various potentially productive directions for future developer-centric automatic patch generation systems.

    Paper (pdf)
  • Using Active Learning to Synthesize Models of Applications That Access Databases
    Jiasi Shen, Martin Rinard
    PLDI 2019: Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation
    Extended version submitted to journal in May 2019

    We present Konure, a new system that uses active learning to infer models of applications that access relational databases. Konure comprises a domain-specific language (each model is a program in this language) and associated inference algorithm that infers models of applications whose behavior can be expressed in this language. The inference algorithm generates inputs and database configurations, runs the application, then observes the resulting database traffic and outputs to progressively refine its current model hypothesis. Because the technique works with only externally observable inputs, outputs, and database configurations, it can infer the behavior of applications written in arbitrary languages using arbitrary coding styles (as long as the behavior of the application is expressible in the domain-specific language). Konure also implements a regenerator that produces a translated Python implementation of the application that systematically includes relevant security and error checks.

    Paper (pdf)
  • Active Learning for Inference and Regeneration of Computer Programs that Store and Retrieve Data
    Martin Rinard, Jiasi Shen, Varun Mangalick
    Onward! 2018: Proceedings of the 2018 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software

    As modern computation platforms become increasingly complex, their programming interfaces are increasingly difficult to use. This complexity is especially inappropriate given the relatively simple core functionality that many of the computations implement. We present a new approach for obtaining software that executes on modern computing platforms with complex programming interfaces. Our approach starts with a simple seed program, written in the language of the developer's choice, that implements the desired core functionality. It then systematically generates inputs and observes the resulting outputs to learn the core functionality. It finally automatically regenerates new code that implements the learned core functionality on the target computing platform. This regenerated code contains boilerplate code for the complex programming interfaces that the target computing platform presents. By providing a productive new mechanism for capturing and encapsulating knowledge about how to use modern complex interfaces, this new approach promises to greatly reduce the developer effort required to obtain secure, robust software that executes on modern computing platforms.

    Paper (pdf)
  • Robust Programs with Filtered Iterators
    Jiasi Shen, Martin Rinard
    SLE 2017: Proceedings of 2017 ACM SIGPLAN International Conference on Software Language Engineering
    Distinguished Artifact Award

    We present a new language construct, filtered iterators, for robust input processing. Filtered iterators are designed to eliminate many common input processing errors while enabling robust continued execution. The design is inspired by (1) observed common input processing errors and (2) successful strategies implemented by human developers fixing input processing errors. Filtered iterators decompose inputs into input units and atomically and automatically discard units that trigger errors. Statistically significant results from a developer study demonstrate the effectiveness of filtered iterators in enabling developers to produce robust input processing code without common input processing defects.

    Paper (pdf)

More papers...

Service

  • Artifact Evaluation Committee, SAS 2019
  • Student Volunteer, PLDI 2018
  • Artifact Evaluation Committee, SLE 2016
  • Artifact Evaluation Committee, OOPSLA 2016