Researchers in Programming Languages and Compilers (original) (raw)

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

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 theNew 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 Isabelletheorem 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 Concertproject.

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 Schemeand 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

Concurrency

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 (mleone@cs.cmu.edu)