Deprecated: The each() function is deprecated. This message will be suppressed on further calls in /home/zhenxiangba/zhenxiangba.com/public_html/phproxy-improved-master/index.php on line 456 Researchers in Programming Languages and Compilers
Researchers in Programming Languages and Compilers
Below are links to home pages of researchers working on programming
language theory, design, implementation, and related areas.
Disclaimer: this list is not exhaustive! Please let me
know if you would like to be added
to this list, or if you would like an existing entry modified or
deleted.
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.
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.
Programming languages design and implementation, the design of
the compiler writing language
RIGAL,
software engineering, testing and debugging automation, assertion
languages.
Implementation of mostly functional languages, in particular SML
and Scheme; efficient data representation, separate compilation,
compilation management, cross-module optimizations; language design
Semantics and design of programming languages, type theory,
object-oriented languages, models of higher-order lambda calculus
including subtypes and bounded polymorphism.
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.
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.
Design and implementation of functional and logic programming
languages with emphasis on the integration of both paradigms and
parallel implementations.
Program analysis via abstract interpretation of the aliasing,
synchronization, and communication behavior of concurrent languages
such as Concurrent ML.
Systems for computer-assisted problem solving in programming and
mathematics, such as Nuprl.
Models and program refinement for the Polya
programming language.
First and higher order modal and temporal logics, compositional
verification techniques, process specification languages, and
applications to computer based systems for cooperative work.
Garbage collection, inlining, memory system performance, optimization for
memory hierarchies, partial evaluation, program analysis, compilers for
object-oriented languages.
Type systems and type inference (ML3000), object types, dynamic
types, operational semantics, higher-order unification, explicit
substitutions, partial continuations, application frameworks.
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.
Advanced programming languages; their semantic foundations, analysis,
optimization and implementation; and partial program verification,
both through advanced type systems and interactive program analyses.
Programming languages and compiler construction, semantics-based program
manipulation and program analyses, program specialization, program
composition, metaprogramming, functional and logic programming.
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.
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.
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.
Operational semantics, correctness of program transformations,
continuations, logics and type theory, logical frameworks, partial
evaluation, computational monads, static analysis of programs.
Programming methods and languages, proof techniques for programs,
distributed computing, category theory in computing science, C-mos
switching circuit design.
Language-based programming environments; program slicing,
differencing, and merging; static analysis of programs; and
interprocedural dataflow analysis.
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.
Programming language design and theory, particularly functional
languages, semantics, and type theory. Logic and computation.
Natural language processing.
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.
Programming language design and implementation (Parallel-C++. CHILL96),
language semantics and formal specification, software testing,
programming environments (CHILL96 Debugger).
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.
Semantic based program manipulation and program analyses. Program
specialization (e.g. partial evaluation, deforestation and
supercompilation), flow and binding-time analysis and representation
analysis.
4D graphics and interactivity, program specializaton, run time
code generation, partial evaluation, high level programming languages,
program analysis and optimization, and type theory.
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.
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.
Programming and program design technologies, programming
languages and systems, specification and verification,
program semantics, object-orientation and modularity.
Program analyses and transformations for efficiency improvement,
optimizing compilers, language-based interactive systems, algorithm
design, program development methods.
Compilation of functional programming languages, particularly of
Standard ML for systems programming purposes, literate programming and
other aspects of text formatting.
Computational logic, proof theory, design and theory of logic and
functional programming languages, unification of typed lambda-calculi,
lambda Prolog.
Mathematical models of computation - models and calculi for
concurrent computation; how to present logics to machines; semantics
of high-level programming constructs.
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.
Parallel computing -- languages and implementations, runtime systems,
architectures. Functional languages and implementations, especially
parallel implementations.
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.
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.
Using functional programming to specify and reason about parallel
systems such as digital circuits and data parallel architectures;
nondeterminism; debugging; functional programming environments.
Parallel computing, operating systems, compilers, partial
evaluation, functional programming languages, and all sorts of odd
permutations of these topics.
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
Distributed programming, system architect's language ALADDIN,
integrated compiler development environment GDT/PC ("Grammar Debugging
Tool and Parser Constuctor").
The
Isabelle
theorem prover. Formalizing axiomatic set theory. Formalizing induction and
coinduction principles in set theory and higher-order logic. Standard ML.
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.
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.
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.
Optimizing compilers for high performance architectures, compiler
phase integration, language and compiler support for cluster
computing, optimizing explicitly parallel programs, parallel
compilers.
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.
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.
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).
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.
Design, implementation, and optimization of programming languages, and
the use of program analysis to support program understanding and
transformation.
Efficient compilation of high-level languages, interaction of
languages and compilers with modern architectures, programming
environments, and formal methods.
Compilers for scalable parallel architectures, compilers for
high-performance uniprocessors, parallel and distributed systems,
programming environments and tools, programming languages.
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.
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.
Languages and environments for developing parallel object-oriented
systems; development of information systems, including processes,
techniques, tools, environments, and philosophical aspects.
Formal specifications, concurrent and distributed systems,
programming languages, programming methodology, and search and
retrieval in the information superhighway.
Semantics of declarative languages; higher-order languages and
meta-theories; semantics of concurrency in object-based languages;
effectiveness of implementations.
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.