Hans Boehm

Hans-J. Boehm

Email address: boehm@acm.org

Physical location: Palo Alto, CA

General

I am a software engineer at Google, where I've been since March 2014. I chair the ISO C++ Concurrency Study Group (WG21/SG1). I am an ACM Fellow, and a past Chair of ACM SIGPLAN (2001-2003). I've chaired a variety of SIGPLAN conferences.

Publications

A list of my selected publications is here.

Where I've been

In the past I've worked or studied at:

2014-
Google
1999-2014
HP Labs (Researcher, Research Manager)
1996-1999
SGI (Software Engineer)
1989-1996
Xerox PARC (Researcher)
1984-1989
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)

Past Projects

Things I've worked on more recently:


Interest areas and Past 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. I still maintain the mailing list, etc., but I am only occasionally involved in maintaining the code base.
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. A package to support (somewhat) portable use of atomic memory operations was developed and is distributed as part of the qprof project.
Java implementation and GCJ
I implemented the hash-table-based synchronization mechanism, and a few other pieces for GCJ, the GNU static Java compiler. I also helped build some of the underlying threads infrastructure on Itanium Linux. Slides for an ancient presentation are here.
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 a several papers, as well as a Calculator implementation that is still in occasional use. More recently, I reimplemented both the calculator and library in Java, with some new twists.
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, but hasn't propagated very far. 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).
The Russell Programming Language
At Cornell, the University of Washington, and at Rice, I worked on the semantics and implementation of a polymorphically-typed programming language called Russell. A rather dated implementation can still be found here. The language was mostly designed by Donahue and Demers at Cornell. Unfortunately, some of the good ideas from this and related designs (e.g."templates" with real separate type checking and compilation) still haven't completely made it into mainstream programming languages. (Fortunately, neither did the bad ideas.)


Slides from some recent talks


Miscellaneous
Boehm family personal home page.