Programming language theory

From Wikipedia, the free encyclopedia

Jump to: navigation, search

Programming language theory (commonly known as PLT) is a branch of computer science that deals with the design, implementation, analysis, characterization, and classification of programming languages and their individual features. It is a multi-disciplinary field, both depending on and, in some cases, affecting mathematics, software engineering, linguistics, and even the cognitive sciences. It is a well-recognized branch of computer science, and as of 2009, an active research area, with results published in numerous journals dedicated to PLT, as well as in general computer science and engineering publications. Most undergraduate computer science programs require coursework in the topic.

An unofficial symbol of the field of programming language theory is the lowercase Greek letter lambda. This usage derives from the lambda calculus, a computational model widely used by programming language researchers. Many texts and papers on programming and programming languages utilize the lambda in some fashion. It graces the cover of the classic text Structure and Interpretation of Computer Programs, and the title of many of the so-called Lambda Papers, written by Gerald Jay Sussman and Guy Steele, the developers of the Scheme programming language. A popular website on programming language theory is called Lambda the Ultimate, in honor of Sussman and Steele's work.

Contents

[edit] History

In some ways, the history of programming language theory predates even the development of programming languages themselves. The lambda calculus, developed by Alonzo Church and Stephen Cole Kleene in the 1930s, is considered by some to be the world's first programming language, even though it was intended to model computation rather than being a means for programmers to describe algorithms to a computer system. Many modern functional programming languages have been described as providing a "thin veneer" over the lambda calculus [1], and many are easily described in terms of it.

The first programming language to be proposed was Plankalkül, which was designed by Konrad Zuse in the 1940s, but not publicly known until 1972 (and not implemented until 2000, five years after Zuse's death). The first widely known and successful programming language was Fortran, developed from 1954 to 1957 by a team of IBM researchers led by John Backus. The success of FORTRAN led to the formation of a committee of scientists to develop a "universal" computer language; the result of their effort was ALGOL 58. Separately, John McCarthy of MIT developed the Lisp programming language (based on the lambda calculus), the first language with origins in academia to be successful. With the success of these initial efforts, programming languages became an active topic of research in the 1960s and beyond.

Some other key events in the history of programming language theory since then:

[edit] Sub-disciplines and related fields

There are several fields of study which either lie within programming language theory, or which have a profound influence on it; many of these have considerable overlap.

  • Compiler theory is the theory of writing compilers (or more generally, translators); programs which translate a program written in one language into another form. The actions of a compiler are traditionally broken up into syntax analysis (scanning and parsing), semantic analysis (determining what a program should do), optimization (improving the performance of a program as indicated by some metric; typically execution speed) and code generation (generation and output of an equivalent program in some target language; often the instruction set of a CPU).
  • Type theory is the study of type systems; which are "tractable syntactic method(s) for proving the absence of certain program behaviors by classifying phrases according to the kinds of values they compute." (Types and Programming Languages, MIT Press, 2002). Many programming languages are distinguished by the characteristics of their type systems.
  • Formal semantics is the formal specification of the behavior of computer programs and programming languages, and refers to the study of Formal language.
  • Program transformation is the process of transforming a program in one form (language) to another form; program analysis is the general problem of examining a program and determining key characteristics (such as the absence of classes of program errors).
  • Runtime systems refers to the development of programming language runtime environments and their components, including virtual machines, garbage collection, and foreign function interfaces.
  • Comparative programming language analysis seeks to classify programming languages into different types based on their characteristics; broad categories of programming languages are often known as programming paradigms.
  • Metaprogramming is the generation of higher-order programs which, when executed, produce programs (possibly in a different language, or in a subset of the original language) as a result.
  • Domain-specific languages are languages constructed to efficiently solve problems in a particular problem domain.

In addition, PLT makes use of many other branches of mathematics, including computability theory, category theory, and set theory.

[edit] PLT-specific journals and publications

Journals which publish original research in programming language theory include:

  • ACM Transactions on Programming Languages and Systems [2]
  • Computer Languages, Systems, and Structures [3]
  • Journal of Functional Programming, The
  • Journal of Functional and Logic Programming, The
  • Journal of Symbolic Computation, The
  • Theoretical Computer Science

A more complete bibliography is available here; also see the list of publications in computer science.

[edit] See also

[edit] External links

Retrieved from "http://en.wikipedia.org/wiki/Programming_language_theory"
Personal tools
Languages