PLSE Reading Group

Autumn 2017 — Friday, 3:30pm — CSE 203

Subscribe to the calendar: iCal or Google Calendar.

We’ll be reading and discussing exciting recent papers from the broader Software Engineering and Programming Language community, with a slight bias toward topics folks in UW PLSE are exploring.

Some paper links may point into the ACM Digital Library or the Springer online collection. Using a UW IP address, or the UW libraries off-campus access, should provide access.

Date Who What
Sep 29

Martin, Pavel

Fairness Testing: Testing Software for Discrimination
Oct 6

John, James W

Context Transformations for Pointer Analysis
Oct 13

Zach, Stuart, Bill

Achieving High Coverage for Floating-Point Code via Unconstrained Programming
Oct 20

Sarah, Chandra

Learning Syntactic Program Transformations from Examples
Oct 27

Jared, Max

Cooperative Kernels: GPU Multitasking for Blocking Algorithms
Nov 3

Benjamin Ylvisaker

Visitor Talk: JavaScript vs Atomicity and a New Tweak on Cooperative Threads
Nov 17

Remy, Chenglong

Verifying Equivalence of Spark Programs
Dec 1

Doug, Nate

Verifying a high-performance crash-safe file system using a tree specification
Dec 8

Calvin, Talia

Reluplex: An Efficient SMT Solver for Verifying Deep Neural Networks

Scheduling

Feel free to swap papers and dates or add yourself as a co-presenter to a topic.

Benjamin Ylvisaker Visit

On November 3, Benjamin Ylvisaker will be visiting reading group to give a talk on JavaScript vs Atomicity and a New Tweak on Cooperative Threads. Abstract:

The major JavaScript implementations (and many other application programming environments) use a single-threaded event loop model for multitasking. This approach makes it relatively easy to avoid some concurrency bugs (e.g. low-level data races are impossible). Unfortunately, some developers think that these systems are generally free from concurrency concerns. This is absolutely not the case! In particular the Scylla and Charybdis of single-threaded concurrency models are unresponsiveness and atomicity violations.

This talk addresses two related topics: First, we will discuss the results of an empirical study of popular web applications. We will see that most such applications heavily use programming patterns that are risky from an atomicity perspective.

Second we propose a new tweak on cooperative multithreading that gives programmers better control over the responsiveness/atomicity dilemma. The main idea behind this tweak is that control over whether a particular call is atomic or interruptible should be in the hands of the caller, not the callee.

Folks should check out these papers for background before the talk:

Some Options for Winter