My primary interest is making advanced programming languages be useful for writing enterprise size programs. An important component of this is enabling the generation of efficient code for such programs. My work generally involves the use of program analysis methods to achieve this goal.
When one does enough work in the area of program analysis for imperative programs, one often discovers that almost every program analysis has a pointer analysis component. Whether you are trying to do partial evaluation, compiler optimizations, or memory management, there is almost always a pointer analysis or aliasing problem that needs to be solved.
In order to analyze real-world programs with multiple millions of lines of code, I use type inference techniques. An early foray into this area is described in a POPL'96 paper. Subsequent algorithms have offered improvements in representing structured data, using a hierarchy of location types to represent restricted subsets, and polymorphic type systems offering context-sensitive results.
I am interested in various kinds of automatic memory management. This includes both conventional garbage collection algorithms and region-based memory management. I am also interested in real-time automatic memory management.
Approaching the memory management problem from a program analysis background, my general approach is to try to reduce the amount of work to be done by garbage collectors.
One approach is to reduce the amount of data managed by a garbage collector by doing some variant of compile-time garbage collection. One example of this is stack-allocation of objects. Another example is doing region-based memory management for part of the program data.
Another approach is to try to divide the program data into "bins" such that data in a bin can be managed somewhat independently from data in other bins. One example of this is to allocate thread-specific objects in thread-specific heaps with thread-specific garbage collectors.
Soft real-time garbage collection is being explored within the context of the Singularity project. Concepts being explored include very small pause times in concurrent collectors, giving the operating system a say in the scheduling of garbage collection, and changing memory usage strategies according to overall system performance and constraints.
Several of the above interests come together in Singularity, a managed code operating system. In addition, the many different types of programs in an operating system demand different kinds of libraries and runtime support. Novel program composition techniques can be used to compose many different runtime environments from a common set of components.