Researchers in Programming Languages and Compilers

Below are links to 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.

Last Name: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Back to the language research page

Related Pages

Home Pages

Martín Abadi - DEC SRC
Security in distributed systems, specification and verification methods, principles of programming languages.
Samson Abramsky - University of Edinburgh
Semantics of programming languages, concurrency, game semantics, program analysis.
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.
Maria Alpuente - Technical University of Valencia (Spain)
Logic Programming: semantics, extensions and applications integration of functional and logic programming languages abstract interpretation, program manipulation.
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.
Zena Matilde Ariola - University of Oregon
Principles of programming languages, formal semantics.
Arvind - MIT
All aspects of parallel computing and declarative programming languages. Dynamic dataflow architectures, the implicitly parallel programming language Id, and the compilation of languages such as Id on parallel machines.
Mike Ashley - University of Kansas
Program analysis, program transformations, language design and implementation.
Mikhail Auguston - New Mexico State University
Programming languages design and implementation, the design of the compiler writing language RIGAL, software engineering, testing and debugging automation, assertion 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.
Thomas Ball - Bell Laboratories, Lucent Technologies
Dynamic analysis of programs, domain-specific languages, software visualization, software tools
Carlos Baquero - Minho University
Concurrent object oriented programming, inheritance of concurrency control code, C++ extensions, transactions on distributed and mobile computing.
Gerald Baumgartner - Purdue
Functional and object-oriented languages, type systems, object types, modules.
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.
Sandip K. Biswas - University of Pennsylvania
Compilers, type theory, module systems, separate compilation, configuration management, program slicing.
Michael R. Blair - MIT
Dynamically adaptive profile-guided specialization, partial evaluation, program analyisi, compilation, type theory, subtyping.
Guy Blelloch - Carnegie Mellon
Parallel languages and compilers. NESL.
Matthias Blume - Princeton
Implementation of mostly functional languages, in particular SML and Scheme; efficient data representation, separate compilation, compilation management, cross-module optimizations; language design
Alan Borning - University of Washington
Constraint-based languages and systems.
Lee Braine - University College London
Functional programming, object-oriented programming, visual programming, and language implementations.
Franck van Breugel - University of Pisa
Operational and denotational semantics of concurrent programming and specification languages, metric spaces.
Preston Briggs - Rice
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.
Barrett R. Bryant - The University of Alabama at Birmingham
Compiler design, formal semantics, object-oriented technology.
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.

Philippe Canalda - INRIA Rocquencourt
PAGODE: a generator of optimizing code generators, compilation techniques, CoSy : an optimizing compiler platform, software engineering, automatic term rewriting system generation, term and DAG normalization problem, non-deterministic finite state automata with non-linear and unification pattern constraints, dynamic programming, reentrant programming, pattern matching.
Luca Cardelli - DEC SRC
Theory of programming languages: polymorphism, subtyping, objects, recursion, modularization, typechecking, distribution. Modula-3, Obliq, ML2000.
Steve Carr - Michigan Technological University
Compilers for instruction-level parallel architectures.
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.
Thomas Christopher - Illinois Institute of Technology
Parallel programming languages, compilers, experimental programming models, message-driven computing, and Icon.
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 Clack - University College London
Language design, programming environments and techniques (especially functional programming), high performance computing
William D Clinger - Northeastern
Higher order and functional languages: design and specification, optimizations and their correctness, generational garbage collection.
Chris Colby - Carnegie Mellon
Program analysis via abstract interpretation of the aliasing, synchronization, and communication behavior of concurrent languages such as Concurrent ML.
Jean-Francois Collard - CNRS, Laboratory PRISM
Static analyses, dataflow analyses, automatic parallelization, scheduling, data-parallel functional programming
Charles Consel - University of Rennes/IRISA
Static program analysis, compilation and compiler generation, programming environment, prototyping and program transformation.
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.
Daniel E. Cooke - University of Texas at El Paso
High-level language development. Recently developed language, SequenceL.
Gordon V. Cormack - University of Waterloo
Parsing and text processing, attribute grammars, data types, concurrency.
Patrick Cousot - ENS, Paris
Static program analysis, abstract interpretation, program development and verification, semantics.
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.
Ron Cytron - Washington University in St. Louis
Program optimization, program transformation, intermediate representations.

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.
Olivier Danvy - Aarhus University
Programming languages, partial evaluation, continuations.
Rowan Davies - Carnegie Mellon
Type systems, ML, refinement types, partial evaluation, computation staging, program analysis.
Jeffrey Dean - Digital Equipment Corporation, Western Research Laboratory
Efficient profiling techniques (DCPI), optimization techniques for object-oriented & high-level languages like Cecil, low-level code scheduling, software tools for performance understanding
Mourad Debbabi - Laval University, Quebec
Programming languages, integration of paradigms, semantics and formal methods.
André DeHon - MIT
Quasistatic computing, specialization, feedback, and adaptation
Arie van Deursen - CWI, Amsterdam
Language prototyping, algebraic specifications, language-specific tools, program understanding, software reengineering.
Stephan Diehl - Universitaet des Saarlandes (University Saarbruecken)
Semantics of programming languages, semantics directed generation of compilers and abstract machines, meta-programming, WWW programming languages.
T. B. Dinesh - CWI
Object oriented programming; algebraic specifications; theorem proving; visual languages; partial evaluation; ASF+SDF; static program analysis
Pedro Diniz - University of California, Santa Barbara
Parallelizing compilers, program analysis and optimization of sequential and parallel programs, dynamic feedback techniques.
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.
Bruce F. Duba - Microsoft Research
Design and implementation of programming languages.
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 - Rice University
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 - AT&T Research
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.
Jeanne Ferrante - University of California, San Diego
Intermediate representations for optimizing and parallelizing compilers; optimization in parallel and memory hierarchy machines.
Andrzej Filinski - Edinburgh
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
Advanced programming languages; their semantic foundations, analysis, optimization and implementation; and partial program verification, both through advanced type systems and interactive program analyses.
Ian Foster - Argonne National Laboratory
Parallel languages, compilers, runtime systems, applications.
Christopher W. Fraser - Bell Laboratories
Retargetable code generation and optimization, including lcc, a retargetable compiler for ANSI C.
Timothy Freeman - Carnegie Mellon
Refinement types, ML
Dan Friedman - Indiana University
Principles of programming languages
Svend Frølund - HP Labs
Object-oriented languages; language support for coordination, distribution, concurrency, persistence, and fault-tolerance.

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.
Giorgio Ghelli - Pisa University
Database programming languages, type theory, object oriented languages; the object-oriented database programming language Fibonacci.
Andy Gill - Glasgow
Using equational reasoning to perform non-trivial proofs; deforestation; purely functional finite maps; parsing combinators.
Christopher Glaeser - Nullstone Corporation
Methodologies to evaluate compiler optimization and run-time performance.
Robert Glück - DIKU, University of Copenhagen
Programming languages and compiler construction, semantics-based program manipulation and program analyses, program specialization, program composition, metaprogramming, functional and logic programming.
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.
Benjamin Goldberg - New York University
Functional programming, memory management, program optimization
Andrew Gordon - Cambridge
Operational semantics; I/O and concurrency; mechanised verification.
John K. Gough - Queensland University of Technology
Code generation, optimization. Implementation of programming languages, strongly typed imperative languages.
T.C. Nicholas Graham - York University
Functional programming languages, languages for developing user interfaces and multi-media groupware, visual programming environments.
John Greiner - Carnegie Mellon
Language models of complexity, type theory, parallel algorithms.
David Gries - Cornell
Logic as a tool, programming methodology, formal development of programs, semantics of programming languages, compilers.
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
Sandeep K. S. Gupta - Colorado State University
Parallelizing compilers, parallel program synthesis and parallel computing.

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.
Michael Hanus - RWTH Aachen
Type systems for and implementation of logic programming languages, integration of functional and logic programming languages (ALF system), abstract interpretation of logic, functional logic and constraint logic programming languages.
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 - DIKU, University of Copenhagen
Operational semantics, correctness of program transformations, continuations, logics and type theory, logical frameworks, partial evaluation, computational monads, static analysis of programs.
Chris Haynes - Indiana
Type systems, control abstraction, symbolic computation, Scheme.
Fritz Henglein - DIKU, University of Copenhagen
Type inference systems, program analysis, algorithmic and computational complexity, global program optimization
Jonathan M. D. Hill - Oxford
Bulk Synchronous Parallel model; Data-parallel non-strict functional programming; Implementation of the HPF library in Fortran 90
Michael Hind - SUNY at New Paltz, visiting IBM Research
Compiler optimizations and programming languages.
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.
Richard C. Holt - University of Toronto
Object oriented programming languages and teaching programming.
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 - InterTrust Technologies
Language design and implementation; specification languages and tools (e.g., Larch); C++ and the Standard Template Library.
Luke Hornof - University of Rennes/IRISA
Partial evaluation, binding-time analysis, run-time code generation, adaptive operating systems.
Susan Horwitz - University of Wisconsin at Madison
Language-based programming environments; program slicing, differencing, and merging; static analysis of programs; and interprocedural dataflow analysis.
Antony L. Hosking - Purdue University
Programming language design and implementation: compilation, interpretation, and optimization; run-time systems (e.g., garbage collection). Object-oriented database systems; database and persistent programming languages and systems. Empirical performance evaluation of prototype systems.
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 - University of Nottingham
Functional programming; relational programming; polytypic programming; programming calculi; recursion operators; categorical methods.
Graham Hutton - Utrecht University, The Netherlands
Functional and relational programming, category theory in computer science, algebraic approaches to programming.

S. Purushothaman Iyer - North Carolina State University
Abstract Interpretation, Concurrency, Formal methods.

Daniel Jackson - Carnegie Mellon
Tractable representations and analyses of designs and code. Specifications, design methods, static analysis, model checking.
Quinn Tyler Jackson - Lambda Systems Ltd.
Pattern matching, language-to-language translation, OO-to-non-OO modeling
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.
Patrik Jansson - Chalmers
Polytypic programming, functional programming, program calculation
Johan Jeuring - Chalmers
Program calculation, programming methodology, type systems and programming languages for polytypic programming, functional programming.
Trevor Jim - University of Pennsylvania
Semantics, compilers, type inference.
Chang-Hyun Jo - Kyonggi University, Korea
Programming language design and implementation (Parallel-C++. CHILL96), language semantics and formal specification, software testing, programming environments (CHILL96 Debugger).
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.
Martin Jourdan - INRIA, Rocquencourt, France
Attribute grammars (esp. the FNC-2 system), program analysis, compiler construction and generation.

Bill Kalsow - DEC SRC
Modula-3, programming languages and environments, compilers and runtime systems
Fairouz Kamareddine - University of Glasgow
Logic, lambda calculus, type theory.
Jasper Kamperman - CWI
Compilation of term rewriting systems, algebraic, equational and functional languages, lazy rewriting, algebraic specifications.
Uwe Kastens - University of Paderborn, Germany
Methods and tools for language implementation, compilation for parallel machines.
Dinesh Katiyar - Sun Microsystems
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
Abstractions, architectures, binding times, caches, compilers, dynamic compilation, emulation, operating systems, performance analysis, runtime code generation, runtime systems, self-modifying code, instruction-set simulation, threads, tracing, value-specific optimization.
Maurice van Keulen - University of Twente
Type systems, polymorphy, functional programming, database specification, object-orientation, semantics of such languages.
Gregor Kiczales - Xerox PARC
Object-oriented programming, reflection, metaobject protocols, open compilers, efficient compilation of high-level programs.
Sangwook Kim - Kyungpook National University, Korea
Computer and programming languages, visual languages, multimedia langugaes semantic analysis for visual concepts.
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.
Todd Knoblock - Microsoft Research
4D graphics and interactivity, program specializaton, run time code generation, partial evaluation, high level programming languages, program analysis and optimization, and type theory.
Dattatraya Kulkarni - University of Toronto
Compiler optimizations, program transformations
Kwangkeun Yi - Korea Advanced Institute of Science and Technology
Compile-time program analysis, programming environments, program analysis tools, safe programming.

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.
John Launchbury - Oregon Graduate Institute
Functional programming, functional algorithms, the semantics of lazy evaluation, incorporating destructive updates in Haskell, partial evaulation, program analysis.
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.
K. Rustan M. Leino - DEC SRC
Programming and program design technologies, programming languages and systems, specification and verification, program semantics, object-orientation and modularity.
Mark Leone - Indiana University
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.
Michael Leuschel - Katholieke Universiteit Leuven
Partial evaluation and partial deduction, meta-programming and the ground representation, specialised integrity checking.
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
Sheng Liang - Yale
Design and implementation of modern programming languages, modular semantics, compiler generation, portable common back-ends.
Leonid Libkin - University of Pennsylvania
Functional database query languages, semantics of programming languages, partial information
Karl Lieberherr - Northeastern University
Adaptive Software, adaptive architecture description languages.
Jim Lipton - Wesleyan University
Logic programming, type theory, intuitionistic semantics, programming with relations, categorical logic.
Björn Lisper - KTH, Dept. of Teleinformatics
Theory for efficient implementation of declarative languages; Data parallel and functional programming; program transformations.
Y. Annie Liu - Indiana University
Program analyses and transformations for efficiency improvement, optimizing compilers, language-based interactive systems, algorithm design, program development methods.

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
Bernd Mathiske - Hamburg University
Language implementation, portable multi-threaded runtime systems, code generation; distributed persistent languages, code mobility, thread mobility, autonomous network agents; bidirectional language interfacing, cross-language exception handling.
David McAllester - MIT AI Laboratory
Automated reasoning and type inference
Erik Meijer - Utrecht University
Functional programming, semantics directed compiler generation, constructive algorithmics.
Marjan Mernik - University of Maribor, Slovenia
Design and implementation of programming languages, formal language definition, compiler generators, attribute grammars
Olivier Michel - LRI, Université Paris-Sud, Orsay (Paris XI)
Declarative languages, data-parallelism, representation of space, implicit construction of programs, names and name capture, the 8 1/2 language.
Dale Miller - University of Pennsylvania
Computational logic, proof theory, design and theory of logic and functional programming languages, unification of typed lambda-calculi, lambda Prolog.
Robin Milner - Cambridge
Mathematical models of computation - models and calculi for concurrent computation; how to present logics to machines; semantics of high-level programming constructs.
John Mitchell - Stanford
Programming language analysis and design, including module systems, object-oriented programming, type systems, and reasoning about programs; applications of mathematical logic to programming languages and automated reasoning; algorithms for static analysis of programs.
Anwar M. Mohammed - Carnegie Mellon
Compilers: optimizing and parallelizing sequential languages, parallel algorithms, languages, and architectures.
Greg Morrisett - Cornell
Systems hacking in high-level languages, compilers, analysis via types, modeling garbage collection, concurrency, threads.
Christian Mossin - DIKU, University of Copenhagen
Type inference for analysis of functional programs. Program analysis, type systems, logic, lambda calculus and (to some extent) category theory.
Frank Mueller - Humboldt-University Berlin
Compiler optimizations, concurrent programming, prediction of execution time
Robert Muller - Boston College
Compilers for higher-order languages, program representation, program analysis and optimization, extensible parsers.

Uwe Nestmann - INRIA Rocquencourt
Formal Semantics, concurrency theory, translation correctness, pi-calculus.
Kristian Nielsen - DIKU, University of Copenhagen
Deforestation, partial evaluation, supercompilation, program analysis, implementation of functional programming languages, lazy evaluation.
Oscar Nierstrasz - University of Berne
Semantics of object-based concurrency; software composition languages.
Rishiyur Nikhil - DEC CRL
Parallel computing -- languages and implementations, runtime systems, architectures. Functional languages and implementations, especially parallel implementations.
Tobias Nipkow - Technische Universität München
Automatic and interactive theorem proving, system verification, rewriting, unification, lambda-calculus, type systems.
Steve Novack - University of Illinois, Urbana-Champaign
The EVE Mutation Scheduling compiler, fine-grain parallelization, code development environments, and hardware/software co-design. The PROMIS compiler, interactions between source-level and instruction-level transformations.
Lars Nyland - University of North Carolina at Chapel Hill
High-level languages for prototyping parallel algorithms. Development of complex parallel algorithms. Transformation of high-level code to parallel implementations.
Albert Nymeyer - University of Twente, The Netherlands
Co-author of "Practice and Principles of Compiler Building with C" (Prentice Hall), 1996.
The theory and implementation of the bottom-up pattern-matching code-generation technique; combined with a heuristic search method to select optimal code.

John O'Donnell - Glasgow
Using functional programming to specify and reason about parallel systems such as digital circuits and data parallel architectures; nondeterminism; debugging; functional programming environments.
Peter O'Hearn - Syracuse University
Semantic and logical foundations of imperative computation.
Bryan O'Sullivan - Glasgow
Parallel computing, operating systems, compilers, partial evaluation, functional programming languages, and all sorts of odd permutations of these topics.
James O'Toole - MIT
Storage systems design for information retrieval and persistent object applications.
Atsushi Ohori - Kyoto University
Type inference, polymorphic record calculus, compilation, parallelism.
Martin Odersky - University of Karlsruhe
Formal methods for the definition of programming languages and the design and manipulation of programs. Special areas of interests are program calculi, type systems, semantics of programming languages, and programming language implementation.
John Ophel - La Trobe University, Melbourne Australia
Polymorphic programming languages, first-class modules.
Mehmet A. Orgun - Macquarie University, Sydney
Logic programming, applied temporal logic, dataflow computation, temporal databases.

Jens Palsberg - MIT
Theory and implementation of programming languages.
Didier Parigot - INRIA Rocquencourt
Attribute grammars, the FNC-2 system.
Algirdas Pakstas - Agder College
Distributed programming, system architect's language ALADDIN, integrated compiler development environment GDT/PC ("Grammar Debugging Tool and Parser Constuctor").
Krishna Palem - New York University
Optimizing compilers, instruction-level parallelism, instruction scheduling and register allocation, compiling for embedded systems.
George A. Papadopoulos - University of Cyprus
Term graph rewriting systems, coordination models, logic, functional and object-oriented programming.
Larry Paulson - Cambridge
The Isabelle theorem prover. Formalizing axiomatic set theory. Formalizing induction and coinduction principles in set theory and higher-order logic. Standard ML.
Frank Pfenning - Carnegie Mellon
Type theory and its application to language design, in particular logic- and functional-programming languages. Logic, automated theorem proving, formal program development, and programming environments.
Michael Philippsen - ICSI, Berkeley
Languages and compilers for parallel and distributed machines.
Benjamin C. Pierce - Indiana University
Static type systems, subtyping, bounded quantification, type inference, lambda-calculus, intersection types, concurrency.
John Plevyak - University of Illinois, Urbana-Champaign
Concurrent object-oriented programming language design and compilation. Type Inference. Structure Analysis. Concurrent C++. The Illinois Concert project.
Gordon Plotkin - Edinburgh
Applications of logic, especially denotational and operational semantics of programming languages; semantics of type systems, monadic theories of computation, general proof theory and the semantics of natural language, particularly type-free intensional logics for situation theory.
Lori L. Pollock - University of Delaware
Optimizing compilers for high performance architectures, compiler phase integration, language and compiler support for cluster computing, optimizing explicitly parallel programs, parallel compilers.
Salil Pradhan - Northeastern University
Adaptive architecture description languages.
Vaughan Pratt - Stanford
Semantics of parallel and distributed computing.
Jan F. Prins - University of North Carolina at Chapel Hill
High-level programming languages; formal techniques in program development; parallel algorithms and parallel computation; compilation of programs for parallel execution.
William Pugh - University of Maryland
Algorithms and data structure design and analysis, skip lists, compilers for massively parallel architectures, integer programming for array data dependence analysis.

Henrik Quintel - Fachhochschule Worms, Deutschland, Germany
Development of parallel compilers and high-speed Front-end/Back-end generators. Working on Q, a parallel, object-oriented programming language.

J. Ramanujam - Louisiana State University
Parallelizing compilers, high-performance computing, programming languages, computer architecture, programming environments.
Norman Ramsey - University of Virginia
Machine-code tools, retargetability, literate programming, and debugging.
Chris Reade - Brunel University
Functional programming, functional I/O, theory of programming languages, type theory, and formal methods.
Jonathan Rees - MIT
Scheme, user-defined data types, lexically scoped macros, modules, categories, monads, Scheme-based operating systems.
Jakob Rehof - DIKU, University of Copenhagen
Type systems; type inference; logical and computational aspects of type systems; type systems in program analysis.
Alastair Reid - Glasgow
Use and implementation of functional languages (graphics, garbage collection, user interfaces, debugging). Formal program development (transformation and implementation of algebraic specifications of abstract data types).
John Reif - Duke
Parallel algorithms, compilers for parallel machines, formal methods for synthesis of parallel algorithms.
Mark Reinhold - NEC Research Institute
Garbage collection, compilation techniques, type systems, semantics, and the visualization and analysis of program performance.
Didier Remy - INRIA Rocquencourt
Type systems; object oriented programming.
Thomas Reps - University of Wisconsin at Madison
Language-based programming environments; program slicing, differencing, and merging; interprocedural dataflow analysis; and incremental algorithms.
Jon G. Riecke - Bell Laboratories
Theory of programming languages: operational and denotational semantics, logics of programs, formal methods, type systems and inference, abstraction. Higher-order languages with state, control, polymorphism.
Kristoffer Rose - DIKU, University of Copenhagen
Semantics, lambda calculus, rewrite systems, explicit substitution, abstract machines, sharing, graph reduction.
Guido van Rossum - CWI (Centre for Mathemathics and Computer Science), Amsterdam
Object-oriented languages, scripting languages, prototyping languages; designed and implemented Python, co-implemented ABC
Francois Rouaix - INRIA Rocquencourt
Extensions of the ML type system, overloading, object-oriented programming, abstract types, type operators, modularity.
Erik Ruf - Microsoft Research
Design, implementation, and optimization of programming languages, and the use of program analysis to support program understanding and transformation.
Barbara Ryder - Rutgers
Compile-time program analyses and software tools for parallel/sequential programming environments. Chair of ACM SIGPLAN.

Amr Sabry - University of Oregon
Compilers, data flow analysis, abstract interpretation, programming language calculi, and semantic foundations.
David Sands - DIKU, University of Copenhagen
Programming language semantics, and their applications to abstract interpretation and related semantics based analysis techniques.
Don Sannella - Edinburgh LFCS
Formal development of modular software from specifications. Modularization mechanisms. Machine-assisted proof. Semantics.
Patrick Sansom - Glasgow
Implementation and runtime support of pure functional languages, including compiler analysis and optimisation, garbage collection, and profiling.
Joao A. Saraiva - Universidade do Minho
Compilers, attribute grammars, parallel compilation.
Andre Scedrov - University of Pennsylvania
Mathematical logic, mathematical aspects of programming structures.
Bill Scherlis - Carnegie Mellon
Semantics-based program analysis and manipulation, information structures.
David Schmidt - Kansas State
Denotational semantics and intuitionistic type theory.
Michael I. Schwartzbach - BRICS, University of Aarhus
Programming languages: type systems, type inference, static program analysis, data types, language design, implementation.
Cotton Seed - MIT and the Motorola Cambridge Research Center
Computer architecture, compilers for MPPs, dataflow and implicitly parallel languages, program analysis, auto-parallelization.
Peter Sestoft - Royal Veterinary and Agricultural University, Denmark
Functional programming languages and their implementation, program analysis and transformation, and partial evaluation.
Zhong Shao - Yale
Efficient compilation of high-level languages, interaction of languages and compilers with modern architectures, programming environments, and formal methods.
Tim Sheard - Oregon Graduate Institute
Compile-time reflection, type parametric programming, program transformation, and algebraic programming.
Olin Shivers - MIT
Advanced programming languages (such as Scheme and ML), systems, and personal user interfaces.
Duncan Sinclair - University of Strathclyde
Functional programming and in particular, how HCI research could be used to make creation of graphical user interfaces for functional programs easier.
Satnam Singh - Glasgow
Using functional languages for hardware specification, synthesis and analysis.
Jonas Skeppstedt - Halmstad University, Sweden
Application-level code optimisation; data prefetching; cache coherence protocols
Anthony Sloane - James Cook University
Generation of programming language implementations, tools and environments from high-level specifications.
Scott F. Smith - Johns Hopkins
Operational semantics of imperative, object-oriented, and concurrent programming languages. Operational equivalence of programs, logics of programs.
Ellen Spertus - MIT
Value dependence graph IR, code generation and register allocation for superscalar/superpipelined architectures.
Vugranam C. Sreedhar - McGill University
Data flow analysis, compiler optimization, instruction level parallelism, multithreaded architecture, optimizing explicit parallel programs, memory consistency models.
Bjarne Steensgaard - Microsoft Research
Static program analysis, program transformation, value dependence graph IR, data flow analyses, store splitting, partial evaluation.
Patrick Steyaert - Brussels Free University
Reflection and object-oriented programming languages and systems; User interfaces, user interface building, application building.
Allen Stoughton - Kansas State
Programming language semantics, full abstraction, models of the applied typed lambda calculus PCF, logical relations and lambda definability.
David Stoutamire - International Computer Science Institute
Compiling for distribution, compiling for locality, garbage collection, Sather.
Dave WJ Stringer-Calvert - University of York, UK
Compiler verification and the PVS verification system.

Walid Taha - Oregon Graduate Institute
Transformational programming systems, functional programming, object-oriented programming, software engineering and compilers.
Carolyn Talcott - Stanford
Formal reasoning, semantics of programming languages, open distributed systems, reflection.
Domenico Talia - ISI-CNR, Rende, Italy
Parallel computing architectures, concurrent programming languages, distributed systems.
Bob Tennent - Edinburgh
Semantics and design of programming languages and logics.
George K. Thiruvathukal - Lake Shore Labs; Metromail Corp; Illinois Institute of Technology
Object oriented languages, enhanced actors programming model, virtual machines, parallel and distributed programming languages, class libraries and typing systems.
Stephen Thomas - University of Nottingham
Use and implementation of functional languages; the design of abstract architectures for functional languages, particularly the TIM.
Frank Tip - IBM T.J. Watson
Program analysis, program transformation/restructuring, program slicing, optimizations of object-oriented programs.
Mario Tokoro - Keio University
Object-oriented computing, concurrent programming, distributed and open systems, and cooperative problem solving.
Andrew Tolmach - Portland State University
Functional language implementation and tools.
David Toman - Kansas State
Implementation of PROLOG and LP languages, semantics of LP languages, semantics and expressivity of database query languages.
David N. Turner - Glasgow
Type systems, type-based program analysis, functional programming, pi-calculus, implementation of concurrent calculi.
Chau-Wen Tseng - University of Maryland
Compilers for scalable parallel architectures, compilers for high-performance uniprocessors, parallel and distributed systems, programming environments and tools, programming languages.
Franklyn Turbak - Wellesley College
Programming language semantics and implementation, deforestation, type-based compilation, visual languages, robot languages.

Mark Vandevoorde - MIT
Optimizing programs with specifications
Eelco Visser - University of Amsterdam
Formalisms and tools for language design and prototyping: syntax definition, type systems, documentation tools; grammar formalisms, parsing, algebraic specification, ASF+SDF.
German Vidal - Technical University of Valencia, Spain
Integration of functional and logic programming languages, abstract interpretation, sematics-based program transformation.

Philip Wadler - Glasgow
Linear logic, monads, call by need, type classes, parametricity, deforestation, strictness analysis, data abstraction, and garbage collection.
William M. Waite - University of Colorado at Boulder
Automation of compiler construction
Chris Walton - Edinburgh LFCS
Standard ML, type systems, mobile code
Mitchell Wand - Northeastern
Semantics, compiler correctness, type inference.
David Watt - University of Glasgow
Action semantics, language design, semantics-directed compiler generation, rapid prototyping.
Martin Weichert - Chalmers
William E. Weihl - MIT
Parallel and distributed systems, programming languages, compilers, operating systems, and computer architecture.
Pierre Weis - INRIA
Design and implementation of functional programming languages, in particular their compilation and type systems, and in particular the Caml language.
Daniel Weise - Microsoft Research
Using advanced representations and analysis to build better compilers and programming tools. Still seeking the holy grail of abstraction without cost even though I don't explicitly hack partial evaluation anymore.
Morten Welinder - DIKU, University of Copenhagen
Partial evaluation of Standard ML, binding-time analysis, hand-writing program generator generators.
David B. Whalley - Florida State University
Compiler optimizations, support tools for performance evaluation and diagnosing compiler errors, predicting execution time.
Paul R. Wilson - University of Texas at Austin
Memory management (garbage collection, allocators), persistence (Texas p-store), extensible languages and compilers (RScheme), memory hierarchies, free software.
Russel Winder - University College London
Languages and environments for developing parallel object-oriented systems; development of information systems, including processes, techniques, tools, environments, and philosophical aspects.
Jeannette Wing - Carnegie Mellon
Formal specifications, concurrent and distributed systems, programming languages, programming methodology, and search and retrieval in the information superhighway.
Michael Winikoff - Melbourne University
Logic programming, linear logic, Lygon, functional programming.
Michael Wolfe - The Portland Group
Compiler optimizations, compiling for parallel machines
David Wolfram - The Australian National University
Semantics of declarative languages; higher-order languages and meta-theories; semantics of concurrency in object-based languages; effectiveness of implementations.
David Wonnacott - Haverford College
Analysis of array references (including array dataflow analysis), constraint manipulation (Presburger Arithmetic), optimization for memory locality.
Andrew Wright - NEC Research Institute
Soft typing, type systems, compilation techniques, Scheme, ML.
Limsoon Wong - University of Pennsylvania. Institute of Systems Science, Singapore.
Interoperable systems, multimedia systems, programming methodologies, query languages, and programming language semantics.

Gao Xiaocheng - Beijing University of Aero and Astro (BUAA)
Constraint hierarchy, object oriented languages, Linux.

Takashi Yamanoue - Kyushu Institute of Technology
Visual programming, parallel programming, compiler-compilers, attributed grammars.
Katherine Yelick - U.C. Berkeley
Programming languages and runtime support for parallel machines; optimizing explicitly parallel programs.
Akinori Yonezawa - University of Tokyo
Parallel computation models, programming languages, object-oriented programming, and natural language processing.

Guo-Qiang Zhang - University of Georgia at Athens
Domain theory, semantics of programming languages, applied logic, nonmonotonic reasoning.
Benjamin Zorn - University of Colorado at Boulder
Programming language design and implementation with specific emphasis on language runtime systems and the ways in which they can support efficient program execution and ease of programming.
Back to the language research page

Additions and corrections are welcome! Mark Leone (