Researchers in Programming Languages and Compilers

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

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

Back to the language research page

Related Pages

Home Pages

Martín Abadi - DEC SRC
Security in distributed systems, specification and verification methods, principles of programming languages.
Gul Agha - University of Illinois at Urbana-Champaign
Logic, object-oriented programming, formal semantics, actors.
Alex Aiken - Berkeley
Program analysis, type theory, optimization, constraint theories, functional programming, instruction scheduling.
Hassan Aït-Kaci - Simon Fraser University
Constraint-based programming, object-orientation, logical and functional programming, and the design of compilation techniques.
Thorsten Altenkirch - Chalmers
Type theory, categorical logic and program verification.
Saman Amarasinghe - Stanford
Compilers for parallel machines, SUIF.
Jennifer Anderson - Stanford
Compilers for scalable parallel machines, SUIF.
Peter Holst Andersen - DIKU, University of Copenhagen
Partial evaluation, C-Mix.
Andrew Appel - Princeton
Standard ML of New Jersey. Compilation, optimization, and garbage collection of mostly functional programming languages.
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.
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.
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.
Steve Beaty - Cray Computer Corporation
General: parsing, genetic algorithms, software engineering
Back-end: register assignment, code selection, instruction scheduling
Françoise Bellegarde - Oregon Graduate Institute
Program transformation by rewriting, functional programming, automatic demonstration, and the use of formal methods for software development.
Edoardo Biagioni - Carnegie Mellon
Functional languages, parallel computing and architectures, compilers, networking, operating systems, and I/O.
Lars Birkedal - Carnegie Mellon
Type theory, modules, Standard ML, compilation of ML, the ML Kit, partial evaluation, SML-Mix.
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.
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.
Tim Budd - Oregon State
Programming languages, Leda, implementation techniques, OOP.
Peter Buhr - University of Waterloo
Polymorphism, persistence, concurrency, and concurrent monitoring, visualization and debugging.
Margaret M. Burnett - Oregon State University.
Visual programming languages design, theory, and implementation. (ftp-able papers).
Rod Burstall - Edinburgh
Computer-aided proof and its relation to type theory; development of correct programs with respect to a specification; applications of category theory in computer science.
Luca Cardelli - DEC SRC
Theory of programming languages: polymorphism, subtyping, objects, recursion, modularization, typechecking, distribution. Modula-3, Obliq, ML2000.
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 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.
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 - University of Washington
Practical whole program analysis, partial evaluation, interprocedural optimization for object-oriented languages. The Cecil project.
Mourad Debbabi - Laval University, Quebec
Programming languages, integration of paradigms, semantics and formal methods.
André DeHon - MIT
Quasistatic computing, specialization, feedback, and adaptation
T. B. Dinesh - CWI
Object oriented programming; algebraic specifications; theorem proving; visual languages; partial evaluation; ASF+SDF; static program analysis
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 - Princeton
Improving software development through the design of very high-level and special-purpose programming languages and the development of tools for their efficient implementation, such as the New Jersey Machine-Code toolkit.
Andrzej Filinski - Carnegie Mellon
Continuations, CPS, category theory.
Sigbjorn Finne - Glasgow
Lazy functional languages, specifically Haskell, and their use in the implementation of graphical user interfaces.
Cormac Flanagan - Rice
Analysis and implementation of high-level parallel programming languages.
Ian Foster - Argonne National Laboratory
Parallel languages, compilers, runtime systems, applications.
Christopher W. Fraser - AT&T Bell Laboratories
Retargetable code generation and optimization, including lcc, a retargetable compiler for ANSI C.
Timothy Freeman - Carnegie Mellon
Refinement types, ML
Svend Frølund - University of Illinois at Urbana-Champaign
Infra-structures and languages for sharing and coordination in concurrent object-oriented systems.
David Gelernter - Yale
Linda, parallel programming, software ensembles, artificial intelligence, adaptive parallelism, programming environments for parallelism, realtime data fusion, and expert databases.
Shai Geva - Carnegie Mellon
Semantics, intensional aspects of computation, domain theory, concurrency, functional programming, reasoning about programs.
Giorgio Ghelli - Pisa University
Database programming languages, type theory, object oriented languages; the object-oriented database programming language Fibonacci.
Anwar M. Ghuloum - Carnegie Mellon
Compilers: optimizing and parallelizing sequential languages, parallel algorithms, languages, and architectures.
Andy Gill - Glasgow
Using equational reasoning to perform non-trivial proofs; deforestation; purely functional finite maps; parsing combinators.
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.
Dave Grove - University of Washington
Design, implementation and optimization of advanced object-oriented languages, such as Cecil.
Carl Gunter - University of Pennsylvania
Domain theory, semantics of polymorphism, computational aspects of linear logic, structure and representation of partial information.
Rajiv Gupta - University of Pittsburgh
Parallelizing and optimizing compilers; parallel architectures; distributed, real-time, and fault tolerant computing; software testing and debugging
Mary Hall - Stanford
Interprocedural optimization for parallelizing compilers, SUIF.
Thomas Hallgren - Chalmers
Type systems with subtypes, graphical user interfaces for functional languages.
Kevin Hammond - Glasgow
Design and implementation of pure functional languages, such as Haskell.
John Hannan - Penn State
Operational semantics and type theory; compiler verification; mathematical logic; program transformation; abstract machines.
David R. Hanson - Princeton
lcc, a retargetable compiler for ANSI C. Programming languages, compilers, programming environments.
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
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 - Silicon Graphics (MIPS Technologies)
Language design and implementation; specification languages and tools (e.g., Larch); C++ and the Standard Template Library.
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.
Daniel Jackson - Carnegie Mellon
Tractable representations and analyses of designs and code. Specifications, design methods, static analysis, model checking.
Suresh Jagannathan - NEC Research Institute
Advanced language and compiler technology for the Scheme programming language; the incorporation of formal methods such as continuation models, type inference, abstract interpretation, etc. as a foundation for such a technology; parallel and distributed computing for symbolic and irregular applications.
Sverker Janson - SICS (Swedish Institute of Computer Science)
Foundations, design, and implementation technology for multiparadigm languages that offer a combination of concurrency (distribution), constraints, and mutable state.
Trevor Jim - MIT
Semantics, compilers, type inference.
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
Jasper Kamperman - CWI
Compilation of term rewriting systems, algebraic, equational and functional languages, lazy rewriting, algebraic specifications.
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.
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.
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.
Mark Leone - Carnegie Mellon
Run-time code generation, partial evaluation, compiling functional programs, program analysis and optimization, type theory.
Xavier Leroy - INRIA Rocquencourt
Type systems, module systems, operational semantics, implementation of ML, the Caml Light compiler.
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.
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
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.
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 - University of Erlangen
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.
Tobias Nipkow - Technische Universität München
Automatic and interactive theorem proving, system verification, rewriting, unification, lambda-calculus, type systems.
Steve Novack - University of California, Irvine
Compiling for fine-grain parallelism.
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.
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.
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 - Cambridge
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.
J. Ramanujam - Louisiana State University
Parallelizing compilers, high-performance computing, programming languages, computer architecture, programming environments.
Norman Ramsey - Purdue
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.
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 - AT&T 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 - Chalmers
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.
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, Microsoft Research
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 - CRAI
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.
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 - Stanford
Compiler support for scalable parallel architectures, SUIF.
Franklyn Turbak - MIT
Programming languages as educational tools, the development of new languages to help people convey their thoughts, program visualization, and virtual educational communities.
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.
Philip Wadler - Glasgow
Linear logic, monads, call by need, type classes, parametricity, deforestation, strictness analysis, data abstraction, and garbage collection.
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.
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 - Oregon Graduate Institute
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.
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.
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)