Programming language theory (commonly known as PLT) is a branch of computer science which deals with the design, implementation, analysis, characterization, and classification of programming languages and programming language 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 2006, 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.

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 ^*, and many are easily described in terms of it.

The first programming language (as such) 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:

• In the 1950s, Noam Chomsky developed the Chomsky hierarchy in the field of linguistics; a discovery which has directly impacted programming language theory and other branches of computer science.
• In 1960s, the Simula language was developed by Ole-Johan Dahl and Kristen Nygaard; it is widely considered to be the first example of an object-oriented programming language; Simula also introduced the concept of coroutines.
• In the 1970s:
  • A team of scientists at Xerox PARC led by Alan Kay develop Smalltalk, an object-oriented language widely known for its innovative (and theretofore unknown) development environment.
  • Sussman and Steele develop the Scheme programming language, a Lisp dialect incorporating lexical scoping, a unified namespace, and elements from the Actor model including first-class continuations.
  • Backus, at the 1977 ACM Turing Award lecture, assailed the current state of industrial languages and proposed a new class of programming languages now known as functional programming languages.
  • The emergence of process calculi, such as the Calculus of Communicating Systems of Robin Milner, and the Communicating sequential processes model of C. A. R. Hoare, as well as similar models of concurrency such as the Actor model of Carl Hewitt,
  • The application of type theory as a discipline to programming languages, led by Milner; this application has led to tremendous advances in type theory in years.
• In the 1990s:
  • Philip Wadler introduced the use of monads for structuring programs written in functional programming languages

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.
• 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

PLT-specific journals and publications

Journals which publish original research in programming language theory include:

• ACM Transactions on Programming Languages and Systems ^*
• Computer Languages, Systems, and Structures ^*
• 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.

See also

• Timeline of programming languages
• Lambda the Ultimate

External links

• The History of Haskell
• Computer Languages History
• Frank Atanassow's PLT Online
• Programming Language Research
• Types and Programming Languages by Benjamin Pierce (MIT Press 2002) ^*
• Programming Language Pragmatics, 2nd Edition by Michael Scott (Morgan-Kaufmann, 2006) ^*
• Essentials of Programming Languages by Daniel P. Friedman, Mitchell Wand, and Christopher T. Haynes (MIT Press 2001) ^*

Programming language topics | theoretical computer science

Teoría de lenguajes de programación