I am a software engineer at Google, where I've been since March 2014.
I now work mostly on concurrent programming issues, both generally, and
focussed on Android.
Rice University (Assistant and Associate Professor)
1982-1984
University of Washington (Assistant Professor)
1978-1983
Cornell University (graduate student)
1974-1978
University of Washington (undergraduate student)
1971-1974
Roosevelt High School, Seattle, WA (student)
Past Projects
Recent projects:
I contribute to Android's ART Java language runtime.
I work mostly on addressing concurrent programming, and sometimes
garbage collection issues, in the runtime.
I use experience from the above to uncover and remove obstacles to writing
reliable multithreaded code.
Unfortunately, until the early 2000s, most programming language definitions,
and sometimes even computer architecture specifications, dealt with
concurrency vaguely, or not at all.
They often couldn't efectively serve as a basis for teaching
programmers, or as reasonable guidelines for compiler writers.
I participated in the revision of the
Java "memory model", and subsequently led a successful effort
to properly define shared variable semantics in C and C++.
Until 2017, I chaired the ISO C++ Concurrency Study Group (WG21/SG1),
which officially added thread support to C++ and more properly defined it.
I continue to actively participate in resolving remaining issues.
I implemented the arithmetic evaluation engine for Google's
Android Calculator. It avoids cumulative errors, and provides
arbitrarily scrollable, always accurate, results. The underlying libraries
are
open source.
Some Older Projects:
Conservative Garbage Collection
This work was started at Rice University, where it
grew out of work on the
implementation of the Russell programming language, which was
jointly developed with Alan Demers.
It was developed substantially further at Xerox PARC, SGI, and HP,
with the help
of many other contributors.
It resulted in a generally available and widely used
garbage collector library,
as well as a number of publications.
It is currently maintained primarily by Ivan Maidanski.
Multiprocessor Synchronization Algorithms
I have worked on fast lock implementations for Java virtual
machines, and I'm generally interested in fast multiprocessor
synchronization. I coauthored a paper on
practical implementation of monitor locks without hardware support.
I developed libatomic_ops, which was useful at the time,
and helped us to avoid some
of its mistakes in the later design of C++11 atomics.
Constructive Real Arithmetic
Together with Corky Cartwright, Vernon Lee, and others,
I explored practical implementations of "exact" real computer arithmetic.
Numbers are represented exactly internal to the computer, in a form
that allows evaluation to any requested precision for display.
This resulted in several papers and a sequence of implementations,
including a Java one. It served
as the basis of the more recent work on arithmetic in Google's
Android calculator.
Ropes or Scalable Strings
The Xerox Cedar environment relies heavily on a scalable implementation
of strings, i.e. sequences of characters represented as trees.
(The Cedar implementation was
developed by Russ Atkinson, Michael Plass, and others. Similar ideas
were also developed elsewhere.) This idea simplifies many
interesting software systems.
I reimplemented it both in C at Xerox (the cord package, now a part of the
garbage collector distribution) and in a very different form for C++ at
SGI (the "rope" package in the
SGI STL).
