Hans-J. Boehm

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.

Understanding how to program systems with non-volatile
byte addressable memory. We expect that such memory will become
far more common, and it is not yet clear if and how it will impact our
basic programming model.

Helping to uncover and remove obstacles to writing
reliable multithreaded code.
Unfortunately, programming language definitions,
and sometimes even computer architecture specifications, have historically been so
vague that they couldn't possibly 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 more recently led a successful effort
to properly define shared variable semantics in C and C++.
This was part of a larger effort to add thread support to those
languages.

Understanding the compiler optimization consequences of the
preceding work. Some time-honored optimization techniques
(e.g. certain flavors of register promotion and vectorization) are now
clearly wrong in light of the preceding work, and were arguably
wrong all along. Other techniques that previously suffered from uncertain
legitimacy are now clearly correct.

Alternative approaches to shared memory programming that simplify
(or perhaps make possible) the programmer's job. I participate in
the C++ transactional memory standardization effort (WG21/SG5).
I have worked on "always on" data-race detection.

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.
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.
The most recent of these implementations,
now also 15 years old, recently became the basis of the arithmetic
implementation in the default 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, 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.)