I am a programming language researcher at Microsoft Research Asia's Systems Research Group who focuses on design, objects, IDEs, live programming, and how we could program with touch. Before working at Microsoft, I obtained my PhD from the University of Utah (advisor Wilson Hsieh) and my BS from the University of Washington, with a post doc at EPFL working on Scala with Martin Odersky.
- Sean McDirmid and Jonathan Edwards, Programming with Managed Time, in SPLASH Onward!, ACM, October 2014
Most languages expose the computer’s ability to globally read and write memory at any time. Programmers must then choreograph control flow so all reads and writes occur in correct relative orders, which can be difficult particularly when dealing with initialization, reactivity, and concurrency. Just as many languages now manage memory to unburden us from properly freeing memory, they should also manage time to automatically order memory accesses for us in the interests of comprehensibility, correctness, and simplicity. Time management is a general language feature with a large design space that is largely unexplored; we offer this perspective to relate prior work and guide future research.
We introduce Glitch as a form of managed time that replays code for an appearance of simultaneous memory updates, avoiding the need for manual order. The key to such replay reaching consistent program states is an ability to reorder and rollback updates as needed, restricting the imperative model while retaining the basic concepts of memory access and control flow. This approach can also handle code to enable live programming that incrementally revises program executions in an IDE under arbitrary code changes.
- Sean McDirmid, Usable Live Programming, in SPLASH Onward!, ACM SIGPLAN, October 2013
Programming today involves code editing mixed with bouts of debugging to get feedback on code execution. For programming to be more fluid, editing and debugging should occur concurrently as live programming. This paper describes how live execution feedback can be woven into the editor by making places in program execution, not just code, navigable so that evaluation results can be probed directly within the code editor. A pane aside the editor also traces execution with entries that are similarly navigable, enabling quick problem diagnosis. Both probes and traces are refreshed continuously during editing, and are easily configured based on debugging needs. We demonstrate the usefulness of this live programming experience with a prototype.
- Zhenyu Guo, Sean McDirmid, Mao Yang, Li Zhuang, Pu Zhang, Yingwei Luo, Tom Bergan, Peter Bodik, Madan Musuvathi, Zheng Zhang, and Lidong Zhou, Failure Recovery: When the Cure Is Worse Than the Disease, in HotOS, USENIX, 13 May 2013
Cloud services inevitably fail: machines lose power, networks become disconnected, pesky software bugs cause sporadic crashes, and so on. Unfortunately, failure recovery itself is often faulty; e.g. recovery can accidentally recursively replicate small failures to other machines until the entire cloud service fails in a catastrophic outage, amplifying a small cold into a contagious deadly plague! We propose that failure recovery should be engineered fore-most according to the maxim of primum non nocere, that it “does no harm.” Accordingly, we must consider the system holistically when failure occurs and recover only when observed activity safely allows for it.
- Sean McDirmid, Escape from the Maze of Twisty Classes, in SPLASH Onward!, ACM SIGPLAN, October 2012
Programmers demand more extensive class libraries so they can reuse more code and write less of their own. However, these libraries are often so large that programmers get lost in deep hierarchies of classes and their members that are very broad in number. Yet language designers continue to focus on computation, leaving tools to solve library exploration problems without much help from the language.
This paper applies language design to improve IDE code completion that enables in-situ library exploration. Inference tackles depth by listing completions as long as the program can be “fixed” to support their selection; e.g. “pressed” can be listed as a widget completion since a widget can be a button. Influence mitigates breadth by leveraging types as completion selection models; e.g. a pressed event is more likely to be used on a button than a mouse event. We apply this design to YinYang, a language for programming simulations on tablets using touch-based menus.
- Sean McDirmid, Coding at the Speed of Touch, in SPLASH Onward!, ACM SIGPLAN, October 2011
Although programming is one of the most creative things that one can do with a computer, there is currently no way to make programs on an increasingly popular class of tablet computers. Tablets appear unable to support capable (proﬁcient) programming experiences because of their small form factor and touch-centric input method. This paper demonstrates how co-design of a programming language, YinYang, and its environment can overcome these challenges to enable do-it-yourself game creation on tablets. YinYang’s programming model is based on tile and behavior constructs that simplify program structure for effective display and input on tablets, and also supports the deﬁnition and safe reuse of new abstractions to be competitive with capable programming languages. This paper details YinYang’s design and evaluates our initial experience through a prototype that runs on current tablet hardware.
- Sean McDirmid, Living it up with a Live Programming Language, in OOPSLA Onward!, ACM, October 2007
A dynamic language promotes ease of use through ﬂexible typing, a focus on high-level programming, and by streamlining the edit-compile-debug cycle. Live languages go beyond dynamic languages with more ease of use features. A live language supports live programming that provides programmers with responsive and continuous feedback about how their edits affect program execution. A live language is also based on high-level constructs such as declarative rules so that programmers can write less code. A live language could also provide programmers with responsive semantic feedback to enable time-saving services such as code completion. This paper describes the design of a textual live language that is based on reactive data-ﬂow values known as signals and dynamic inheritance. Our language, SuperGlue, supports live programming with responsive semantic feedback, which we demonstrate with a working prototype.
Sean McDirmid and Jonathan Edwards, Programming with Managed Time, in SPLASH Onward!, ACM, October 2014
Sean McDirmid, Usable Live Programming, in SPLASH Onward!, ACM SIGPLAN, October 2013
Sean McDirmid, Going Against the Flow for Typeless Programming (deprecated), no. MSR-TR-2013-70, July 2013
Sean McDirmid, Escape from the Maze of Twisty Classes, in SPLASH Onward!, ACM SIGPLAN, October 2012
Sean McDirmid, Coding at the Speed of Touch, in SPLASH Onward!, ACM SIGPLAN, October 2011
Sean McDirmid, Living it up with a Live Programming Language, in OOPSLA Onward!, ACM, October 2007