Jiasi Shen

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

My research interests are in programming languages and software engineering. I aim to enable developers to work more effectively with existing programs. I develop techniques that extract and reuse already-implemented functionality.

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

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)
  • 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

    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...


    CAV 2020 AEC, SAS 2019 AEC, SLE 2016 AEC, OOPSLA 2016 AEC