Research at Microsoft

After spending a sabbatical year (1997-98) at MSR, I joined full time in August 1998 and started the Software Productivity Tools (SPT) research group. SPT constructed tools that found defects (bugs) in software, and in the process developed and applied a variety of innovative techniques in static program analysis. The group's research had considerable impact on the research community, as well as being shipped in Microsoft products such as the Static Driver Verifier and FX/Cop and other, widely-used internal software development tools (check out our web page). The group evolved as everyone moved on to new projects in Microsoft Research. Here's what the SPT group looked like in mid-2003:

Next, I became a Research Area Manager for programming languages and tools in Microsoft Research, where I managed the Human Interaction in Programming, Runtime Analysis and Design, Software Reliability Research, and Concurrency Research groups and started and co-led the Singularity research project.

• Advanced Compiler Technology. David Tarditi (dtarditi@microsoft.com) leads the ACT group, which studies compiler and language implementation techniques. It is focused on techniques for implementing modern, safe languages and in compiling for highly parallel hardware. 
• Human Interaction in Programming. Rob DeLine (rdeline@microsoft.com) leads the HIP group, which uses HCI techniques, such as controlled user studies and ethnography, to study software developers, testers, managers and their teams. The goal is to produce innovative software development tools that address human and social issues. 
• Runtime Analysis and Design. Trishul Chilimbi (trishulc@microsoft.com) leads the RAD group, which explores efficient runtime measurement and analysis techniques to improve software quality. It uses hybrid static-dynamic analysis, statistical sampling techniques, continuous online adaptation, and customized program execution environments.
•  Software Reliability Research. Tom Ball (tball@microsoft.com) leads the SRR group, which studies how program analysis, program verification, and software measurement techniques can be used to improve the quality of software. Current projects include CHESS (checking of system software), ESM (Empirical Software Engineering and Measurement), and Zap (automated theorem proving for software analysis).

•  Concurrency Research. The group will focus on improvement in languages, compilers, and tools, with a goal of reducing the complexity and difficult of developing software for parallel computers.

Singularity

My research centered on Singularity, a project that Galen Hunt and I started to focus on the construction of reliable systems through innovation in the areas of systems, languages, and tools (see our overview Technical Report or an video in which Galen and I discuss the project.). Our recent article in Operating Systems Review, Singularity: Rethinking the Software Stack, is a concise introduction to the Singularity project. Even better, the full source for Singularity is available for research and non-commercial investigations. Look on CodePlex.

Here's a quick summary of the project:

Singularity is a research project in Microsoft Research that started with the question: what would a software platform look like if it was designed from scratch with the primary goal of dependability? Singularity is working to answer this question by building on advances in programming languages and tools to develop a new system architecture and operating system (named Singularity), with the aim of producing a more robust and dependable software platform. Singularity demonstrates the practicality of new technologies and architectural decisions, which should lead to the construction of more robust and dependable systems.

Transactional Memory Book

My book on Transactional Memory, written with Ravi Rajwar of Intel, has been published by Morgan & Claypool and is available in hardcopy and on-line:

Transactional Memory Synthesis Lectures on Computer Architecture 2006, 226 pages, (doi:10.2200/S00070ED1V01Y200611CAC002) James R. Larus‌ Microsoft / larus@microsoft.com Ravi Rajwar‌ Intel Corporation / ravi.rajwar@intel.com Abstract The advent of multicore processors has renewed interest in the idea of incorporating transactions into the programming model used to write parallel programs. This approach, known as transactional memory, offers an alternative, and hopefully better, way to coordinate concurrent threads. The ACI (atomicity, consistency, isolation) properties of transactions provide a foundation to ensure that concurrent reads and writes of shared data do not produce inconsistent or incorrect results. At a higher level, a computation wrapped in a transaction executes atomically – either it completes successfully and commits its result in its entirety or it aborts. In addition, isolation ensures the transaction produces the same result as if no other transactions were executing concurrently. Although transactions are not a parallel programming panacea, they shift much of the burden of synchronizing and coordinating parallel computations from a programmer to a compiler, runtime system, and hardware. The challenge for the system implementers is to build an efficient transactional memory infrastructure. This book presents an overview of the state of the art in the design and implementation of transactional memory systems, as of early summer 2006.

Professional History

Before joining Microsoft, I was an Assistant and Associate Professor of Computer Sciences Department at the University of Wisconsin-Madison, where I published approximately 60 research papers and co-led the Wisconsin Wind Tunnel (WWT) research project, with Professors Mark Hill and David Wood. WWT was a DARPA and NSF-funded project investigated new approaches to simulating, building, and programming parallel shared-memory computers. My research spanned a number of areas: including new and efficient techniques for measuring and recording executing programs’ behavior, tools for analyzing and manipulating compiled and linked programs, programming languages for parallel computing, tools for verifying program correctness, and techniques for compiler analysis and optimization. I also wrote some widely distributed software (SPIM, PP, QPT, EEL), all of which is still available. Although, I am not actively enhancing any of these programs, I am still interested in hearing of bugs and problems.

I received my MS and PhD in Computer Science from the University of California, Berkeley in 1989, and an AB in Applied Mathematics from Harvard in 1980. At Berkeley, I developed one of the first systems to analyze Lisp programs and determine how to best execute them on a parallel computer.

I have been an active contributor to the programming languages, compiler, and computer architecture communities. I have published many papers and served on numerous program committees and NSF and NRC panels. I became an ACM Fellow in 2006. My CV has the details.