Researchers in Programming Languages and Compilers

Here are some home pages of researchers working on programming language theory, design, implementation, and related areas.

Disclaimer: this list is not exhaustive! Please let me know if you would like to be added to this list, or if you would like an existing entry modified or deleted.

Back to the language research page

Related Pages

Web Pages

Martín Abadi - DEC SRC
Security in distributed systems, specification and verification methods, principles of programming languages.
Gul Agha - University of Illinois at Urbana-Champaign
Logic, object-oriented programming, formal semantics, actors.
Alex Aiken - Berkeley
Program analysis, type theory, optimization, constraint theories, functional programming, instruction scheduling.
Hassan Aït-Kaci - Simon Fraser University
Constraint-based programming, object-orientation, logical and functional programming, and the design of compilation techniques.
Thorsten Altenkirch - Chalmers
Type theory, categorical logic and program verification.
Saman Amarasinghe - Stanford
Compilers for parallel machines, SUIF.
Jennifer Anderson - Stanford
Compilers for scalable parallel machines, SUIF.
Peter Holst Andersen - DIKU, University of Copenhagen
Partial evaluation, C-Mix.
Andrew Appel - Princeton
Standard ML of New Jersey. Compilation, optimization, and garbage collection of mostly functional programming languages.
Lennart Augustsson - Chalmers
Functional programming and implementation.
Henry Baker - Independent researcher/consultant
Garbage collection, GC, storage management, programming languages, Lisp, Ada, APL, ML, functional programming, compilers, linear types, reversible computation, parallel languages, quantum computation.
Carlos Baquero - Minho University
Concurrent object oriented programming, inheritance of concurrency control code, C++ extensions, transactions on distributed and mobile computing.
Steve Beaty - Cray Computer Corporation
General: parsing, genetic algorithms, software engineering
Back-end: register assignment, code selection, instruction scheduling
Françoise Bellegarde - Oregon Graduate Institute
Program transformation by rewriting, functional programming, automatic demonstration, and the use of formal methods for software development.
Edoardo Biagioni - Carnegie Mellon
Functional languages, parallel computing and architectures, compilers, networking, operating systems, and I/O.
Lars Birkedal - Carnegie Mellon
Type theory, modules, Standard ML, compilation of ML, the ML Kit, partial evaluation, SML-Mix.
Guy Blelloch - Carnegie Mellon
Parallel languages and compilers. NESL.
Matthias Blume - Princeton
Implementation of mostly functional languages, in particular Scheme and SML; efficiency and portability of high-level language implementations; language design
Alan Borning - University of Washington
Constraint-based languages and systems.
Jean-Pierre Briot - University of Tokyo
Object-oriented programming, concurrency/parallelism, meta-programming and reflection, artificial intelligence, artificial life, computer music.
Kim B. Bruce - Williams College
Semantics and design of programming languages, type theory, object-oriented languages, models of higher-order lambda calculus including subtypes and bounded polymorphism.
Tim Budd - Oregon State
Programming languages, Leda, implementation techniques, OOP.
Peter Buhr - University of Waterloo
Polymorphism, persistence, concurrency, and concurrent monitoring, visualization and debugging.
Margaret M. Burnett - Oregon State University.
Visual programming languages design, theory, and implementation. (ftp-able papers).
Rod Burstall - Edinburgh
Computer-aided proof and its relation to type theory; development of correct programs with respect to a specification; applications of category theory in computer science.
Luca Cardelli - DEC SRC
Theory of programming languages: polymorphism, subtyping, objects, recursion, modularization, typechecking, distribution. Modula-3, Obliq, ML2000.
Nicholas Carriero - Yale
Systems issues in the development and deployment of software tools for parallelism
Giuseppe Castagna - LIENS (Laboratoire d'Informatique de l'Ecole Normale Supérieure)
Type theory, object-oriented programming.
Manuel M.T. Chakravarty - Technical University of Berlin
Design and implementation of functional and logic programming languages with emphasis on the integration of both paradigms and parallel implementations.
Craig Chambers - University of Washington
Design and implementation of advanced object-oriented languages. Cecil.
Mark Chu-Carroll - University of Delaware
Programming languages and environments, general purpose parallel programming, compiler analysis and high-level optimization.
Wayne Citrin - University of Colorado
Visual programming languages and environments.
Chris Colby - Carnegie Mellon
Program analysis via abstract interpretation of the aliasing, synchronization, and communication behavior of concurrent languages such as Concurrent ML.
Robert Constable - Cornell
Systems for computer-assisted problem solving in programming and mathematics, such as Nuprl. Models and program refinement for the Polya programming language.
Gordon V. Cormack - University of Waterloo
Parsing and text processing, attribute grammars, data types, concurrency.
Dirk Craeynest - K. U. Leuven
Semantics directed compiler construction, integrated environments, programming language Ada, software engineering.
Roger Crew - Microsoft Research
Semantics, program analysis, verification and transformations.
Mads Dam - Swedish Institute of Computer Science
First and higher order modal and temporal logics, compositional verification techniques, process specification languages, and applications to computer based systems for cooperative work.
Laurent Dami - Université de Genève
The HOP Calculus; integration of functional and object-oriented languages.
Jeffrey Dean - University of Washington
Practical whole program analysis, partial evaluation, interprocedural optimization for object-oriented languages. The Cecil project.
André DeHon - MIT
Quasistatic computing, specialization, feedback, and adaptation
Amer Diwan - University of Massachusetts
Garbage collection, inlining, memory system performance, optimization for memory hierarchies, partial evaluation, program analysis, compilers for object-oriented languages.
Simon Dobson - Rutherford Appleton Laboratory
Programming abstractions for parallel and distributed systems, compilation, program transformation, semantics
Scott Draves - Carnegie Mellon
Partial evaluation, abstraction vs. performance.
Dominic Duggan - University of Waterloo
Type systems and type inference (ML3000), object types, dynamic types, operational semantics, higher-order unification, explicit substitutions, partial continuations, application frameworks.
Dirk Dussart - Katholieke Universiteit Leuven, Belgium
Program specialization techniques.
Susan Eggers - University of Washington
Dynamic compilation, code scheduling, parallel optimizations for locality.
Michael Ernst - Microsoft Research
Static analysis, slicing, debugging (including optimized code), serialization of parallel programs; game theory, intellectual property.
David Espinosa - MIT and Columbia
Monads, compiler and operating system architecture.
Leonidas Fegaras - Oregon Graduate Institute
Functional programming, database programming languages, query optimization, program transformation and verification.
Matthias Felleisen - Rice
Principles of programming languages
Mary Fernandez - Princeton
Improving software development through the design of very high-level and special-purpose programming languages and the development of tools for their efficient implementation, such as the New Jersey Machine-Code toolkit.
Andrzej Filinski - Carnegie Mellon
Continuations, CPS, category theory.
Sigbjorn Finne - Glasgow
Lazy functional languages, specifically Haskell, and their use in the implementation of graphical user interfaces.
Cormac Flanagan - Rice
Analysis and implementation of high-level parallel programming languages.
Christopher W. Fraser - AT&T Bell Laboratories
Retargetable code generation and optimization, including lcc, a retargetable compiler for ANSI C.
Timothy Freeman - Carnegie Mellon
Refinement types, ML
Svend Frølund - University of Illinois at Urbana-Champaign
Infra-structures and languages for sharing and coordination in concurrent object-oriented systems.
David Gelernter - Yale
Linda, parallel programming, software ensembles, artificial intelligence, adaptive parallelism, programming environments for parallelism, realtime data fusion, and expert databases.
Shai Geva - Carnegie Mellon
Semantics, intensional aspects of computation, domain theory, concurrency, functional programming, reasoning about programs.
Anwar M. Ghuloum - Carnegie Mellon
Compilers: optimizing and parallelizing sequential languages, parallel algorithms, languages, and architectures.
Joseph A. Goguen - Oxford
Software engineering; formal methods; object oriented, relational and functional programming and their combinations; concurrent computer architecture based on rewriting; algebraic specification; theorem proving; hardware verification; philosophy of computation.
Andrew Gordon - Cambridge
Operational semantics; I/O and concurrency; mechanised verification.
John Greiner - Carnegie Mellon
Language models of complexity, type theory, parallel algorithms.
Dave Grove - University of Washington
Design, implementation and optimization of advanced object-oriented languages, such as Cecil.
Carl Gunter - University of Pennsylvania
Domain theory, semantics of polymorphism, computational aspects of linear logic, structure and representation of partial information.
Rajiv Gupta - University of Pittsburgh
Parallelizing and optimizing compilers; parallel architectures; distributed, real-time, and fault tolerant computing; software testing and debugging
Mary Hall - Stanford
Interprocedural optimization for parallelizing compilers, SUIF.
Thomas Hallgren - Chalmers
Type systems with subtypes, graphical user interfaces for functional languages.
Kevin Hammond - Glasgow
Design and implementation of pure functional languages, such as Haskell.
John Hannan - Penn State
Operational semantics and type theory; compiler verification; mathematical logic; program transformation; abstract machines.
David R. Hanson - Princeton
lcc, a retargetable compiler for ANSI C. Programming languages, compilers, programming environments.
James Harland - Royal Melbourne Institute of Technology
Foundations of logic programming, linear logic, proof theory, deductive databases, computational logic.
Robert Harper - Carnegie Mellon
Logical frameworks, machine-assisted proofs, ML, ML2000, modules, lambda calculus, type theory, category theory, semantics and logics of programs, functional programming, applications of functional languages to systems programming.
John Hatcliff - Kansas State
Continuations, constructive logics and type theory, computational monads, semantics and implementation of programming languages, static analysis, partial evaluation, persistent programming languages, database programming languages.
Chris Haynes - Indiana
Type systems, control abstraction, symbolic computation, Scheme.
Jonathan M. D. Hill - The London Parallel Applications Centre
Data-parallel non-strict functional programming; using parallel map, fold, and scan to express data-parallel algorithms, e.g., parallel parsing; vectorising non-strict functional languages; data-parallel HPF library in Fortran 90.
C.A.R. Hoare - Oxford
Programming methods and languages, proof techniques for programs, distributed computing, category theory in computing science, C-mos switching circuit design.
Urs Hölzle - University of California, Santa Barbara
Object-oriented programming languages, compilers for object-oriented languages, run-time compilation.
James Hook - Oregon Graduate Institute
Application of formal methods to software development, the theory and practice of specification and programming languages, and type theory.
Jim Horning - DEC SRC
Larch; transformations and verification in circuit design.
Susan Horwitz - University of Wisconsin at Madison
Language-based programming environments; program slicing, differencing, and merging; static analysis of programs; and interprocedural dataflow analysis.
Brian Howard - Kansas State
Programming language design and theory, particularly functional languages, semantics, and type theory. Logic and computation. Natural language processing.
Paul Hudak - Yale
Functional programming, Haskell, parallel programming in Haskell, modular interpreters, mutable abstract datatypes.
Graham Hutton - Utrecht University, The Netherlands
Functional and relational programming, category theory in computer science, algebraic approaches to programming.
Daniel Jackson - Carnegie Mellon
Tractable representations and analyses of designs and code. Specifications, design methods, static analysis, model checking.
Suresh Jagannathan - NEC Research Institute
Advanced language and compiler technology for the Scheme programming language; the incorporation of formal methods such as continuation models, type inference, abstract interpretation, etc. as a foundation for such a technology; parallel and distributed computing for symbolic and irregular applications.
Sverker Janson - SICS (Swedish Institute of Computer Science)
Foundations, design, and implementation technology for multiparadigm languages that offer a combination of concurrency (distribution), constraints, and mutable state.
Cliff B. Jones - Manchester University
Compositional formal methods for parallel environments, support systems for formal methods, LPF.
Mark P. Jones - University of Nottingham
Programming language design and implementation, type theory, module systems, program transformation and analysis, functional programming.
Simon Peyton Jones - Glasgow
Design, implementation, and application of lazy functional languages. In practical terms, that means I spend most of my time on our implementation of Haskell, the Glasgow Haskell Compiler, and its ramifications.
Jesper Jørgensen - DIKU, University of Copenhagen
Semantic based program manipulation and program analyses. Program specialization (e.g. partial evaluation, deforestation and supercompilation), flow and binding-time analysis and representation analysis.
Bill Kalsow - DEC SRC
Modula-3, programming languages and environments, compilers and runtime systems
Dinesh Katiyar - Stanford
Programming languages, object-oriented languages, multi-language systems, interface definition languages, type theory
Richard Kelsey - NEC Research Institute
Compiling scheme, Scheme 48, continuation-passing style.
Andrew Kennedy - University of Cambridge
Type systems, type inference, dimension types and the extension of programming languages to support physical dimension, functional programming.
David Keppel - University of Washington
Runtime code generation and its applications. Simulation and tracing.
David King - Glasgow
Expressing graph algorithms in Haskell, algorithm design and correctness, imperative functional programming.
Edgar Knapp - Purdue
Formal methods for concurrent program development, tool support for program design, retargetable implementation of concurrent programs.
Monica Lam - Stanford
Compiler optimizations, computer architectures, parallel computing, SUIF.
Leslie Lamport - DEC SRC
TLA (the Temporal Logic of Actions), writing proofs.
James Larus - University of Wisconsin at Madison
Programming languages and compilers, in particular languages and compilers for parallel machines; design and programming of shared-memory parallel computers; compiling symbolic languages; program profiling and tracing; and program executable editing.
Konstantin Läufer - Loyola University of Chicago
Programming languages and compilers, functional and object-oriented programming, type systems, type inference, software engineering.
Gary T. Leavens - Iowa State
Programming and specification language design and semantics, formal methods (program specification and verification), programming methodology, object-oriented programming, functional programming, distributed computer systems.
Peter Lee - Carnegie Mellon
Semantics-based compiler generation, program analysis and optimization, ML, compiler support for advanced systems software.
Mark Leone - Carnegie Mellon
Run-time code generation, partial evaluation, compiling functional programs, program analysis and optimization, type theory.
Xavier Leroy - INRIA Rocquencourt
Type systems, module systems, operational semantics, implementation of ML, the Caml Light compiler.
Raph Levien - UC Berkeley
Compilers for higher-order languages; analysis of memory access patterns, closure representations, avoiding the need for garbage collection.
Sean Levy, Allen Dutoit, Eric Gardner, Eswaran Subrahmanian - Carnegie Mellon
n-dim Group, Engineering Design Research Center, CMU
Object-oriented languages/environments, embeddable languages/toolkits, support for evolutionary prototyping, user interfaces, collaboration
Leonid Libkin - University of Pennsylvania
Functional database query languages, semantics of programming languages, partial information
Björn Lisper - KTH, Dept. of Teleinformatics
Theory for efficient implementation of declarative languages; Data parallel and functional programming; program transformations.
Luc Maranget - INRIA Rocquencourt
Lazy ML: compilation of pattern matching and parallel implementation; strategies in term rewriting systems.
Dave Mason - Waterloo
Compilation of functional programming languages, particularly of Standard ML for systems programming purposes, literate programming and other aspects of text formatting.
Florian Matthes - Hamburg University, Germany
Persistent programming environments: extensible syntax, higher-order type checking, static and dynamic code optimization, object store interfaces
David >

Transfer interrupted!