Andrew Quinn is a sixth-year graduate student at the University of Michigan working with Jason Flinn and Baris Kasikci.  He received an NSF fellowship
(2017) and an MSR fellowship (2017).  His research investigates systems, tools, techniques to make software more reliable.  His dissertation focuses on
solutions that help developers better understand their software for tasks such as debugging, security forensics, and data provenance.  In addition, he has
recently been working on solutions to improve the reliability of applications that use emerging hardware, including persistent memory, heterogeneous
systems, and edge computing.

Before Michigan, Andrew attended Dension University where received degrees in Computer Science and Mathematics.  Between his undergraduate and Ph.D. studies,
he worked as a software engineer at IBM.  When not working, Andrew is likely wrestling with his dogs, enjoying a long run around Ann Arbor MI, or baking
something sweet.

SWS   Info

AG Audience

English

60 Minutes

Saarbrücken

Software bugs are pervasive and costly.  As a result, developers spend the majority of their time debugging their software.  Traditionally, debugging involves inspecting and tracking the runtime behavior of a program.  Alas, program inspection is computationally expensive, especially when employing powerful techniques such as dynamic information flow tracking, data-race detection, and data structure invariant checks.  Moreover, debugging logic is difficult to specify correctly.  Current tools (e.g., gdb, Intel Pin) allow developers to write debugging logic in an imperative inline programming model that mirrors the programming style of traditional software.  So, debugging logic faces the same challenges as traditional software, including concurrency, fault handling, dynamic memory, and extensibility.  In general, specifying debugging logic can be as difficult as writing the program being debugged!

In this talk, I will describe a new data-centric debugging framework that alleviates the performance and specification limitations of current debugging models.  The key idea is to use deterministic record and replay to treat a program execution as a massive data object consisting of all program states reached during the execution.  In this framework, developers can express common debugging tasks (e.g., tracking the value of a variable) and dynamic analyses (e.g., data-race detection) as queries over an execution's data object.  My research explores how a data-centric model enables large-scale parallelism to accelerate debugging queries (JetStream and SledgeHammer) and relational query models to simplify the specification of debugging logic (SledgeHammer and the OmniTable Query Model).

--

Please contact MPI-SWS office for Zoom link information

Gretchen Gravelle

+49 681 9303-0

--email hidden

passcode not visible

logged in users only