IMP (programming language)

IMP
Paradigms	Multi-paradigm: procedural, imperative, structured, extensible
Family	ALGOL
Designed by	Edgar T. Irons
Developer	National Security Agency
First appeared	1965;56 years ago
Stable release	IMP72 / 1972;49 years ago
Typing discipline	Static, strong
Scope	Lexical
Implementation language	ALGOL 60
Platform	CDC 6600, Cray, PDP-10, PDP-11
OS	COS, SCOPE, TOPS-10, Unix, others
License	Proprietary
Major implementations
	IMP65, IMP70, IMP72
Influenced by
	ALGOL 60

Last updated August 16, 2021

IMP is an early systems programming language that was developed by Edgar T. Irons in the late 1960s through early 1970s, at the National Security Agency (NSA). Unlike most other systems languages, IMP supports syntax-extensible programming.

Extensible syntax in IMP72

Being an extensible syntax programming language, IMP allows a programmer to extend its syntax, although no specific means are provided to add new data types or structures to it. To achieve its syntax-extensibility, IMP uses a powerful parse algorithm based on a syntax graph and several connectivity matrices. The programmer may add new Backus–Naur form (BNF) productions to the graph.

IMP72's syntax is extended by means of extended-BNF syntax statements included in a source code program. The mechanism is so powerful, that it allowed the implementation of the language by itself, i.e., by an IMP72 source file consisting entirely of syntax statements, which was input to a trivial compiler which was initially able to translate the simplest case of the syntax statement. There is also a simple form of the syntax statement which looks like a macro to the casual user.

Basically, the syntax statement is an augmented BNF production with associated semantics added on the right:

 <class> ::=syntax-part ::=semantic-part

For example, to add the construct described by the following BNF:

 <EXP> ::=INCREMENT <VBL>

with the semantics that INCREMENT V should translate to V ← V + 1, the programmer would only need to insert the following IMP statement:

 <EXP> ::=INCREMENT <VBL,A> ::="A←A+1"

The semantic-part can also contain calls to semantic routines, as in the following syntax statement:

 <ATOM> ::=ABS( <ATOM,A> ) ::=DEWOP(214B,AREG1(1,13),A)

The semantic part of this statement consists of a call on the semantic routine DEWOP. The arguments are the octal constant 214B, the semantic routine call AREG1(1,13), and A, which is the object on top of the stack at the moment this production is invoked. DEWOP is a semantic routine which respectively takes as its arguments a PDP-10 machine language opcode, a register object, and any other object, and produces an object whose value is the result of executing the designated machine instruction using as address field the object which is its last argument. In this example, the opcode 214B designates the Load Magnitude instruction, and thus the result of the above syntax statement will be to compile code to compute the absolute value of A.

Folklore operating system

IMP was the language used on NSA's homegrown time-sharing operating system named Folklore.^[1]

Related Research Articles

ALGOL is a family of imperative computer programming languages originally developed in 1958. ALGOL heavily influenced many other languages and was the standard method for algorithm description used by the Association for Computing Machinery (ACM) in textbooks and academic sources for more than thirty years.

In computing, a compiler is a computer program that translates computer code written in one programming language into another language. The name "compiler" is primarily used for programs that translate source code from a high-level programming language to a lower level language to create an executable program.

C is a general-purpose, procedural computer programming language supporting structured programming, lexical variable scope, and recursion, with a static type system. By design, C provides constructs that map efficiently to typical machine instructions. It has found lasting use in applications previously coded in assembly language. Such applications include operating systems and various application software for computer architectures that range from supercomputers to PLCs and embedded systems.

Dylan is a multi-paradigm programming language that includes support for functional and object-oriented programming (OOP), and is dynamic and reflective while providing a programming model designed to support generating efficient machine code, including fine-grained control over dynamic and static behaviors. It was created in the early 1990s by a group led by Apple Computer.

In computer science, syntactic sugar is syntax within a programming language that is designed to make things easier to read or to express. It makes the language "sweeter" for human use: things can be expressed more clearly, more concisely, or in an alternative style that some may prefer.

In computer science, Backus–Naur form or Backus normal form (BNF) is a metasyntax notation for context-free grammars, often used to describe the syntax of languages used in computing, such as computer programming languages, document formats, instruction sets and communication protocols. They are applied wherever exact descriptions of languages are needed: for instance, in official language specifications, in manuals, and in textbooks on programming language theory.

In computer science, a compiler-compiler or compiler generator is a programming tool that creates a parser, interpreter, or compiler from some form of formal description of a programming language and machine.

In computer science, a high-level programming language is a programming language with strong abstraction from the details of the computer. In contrast to low-level programming languages, it may use natural language elements, be easier to use, or may automate significant areas of computing systems, making the process of developing a program simpler and more understandable than when using a lower-level language. The amount of abstraction provided defines how "high-level" a programming language is.

In computer science, a for-loop is a control flow statement for specifying iteration, which allows code to be executed repeatedly. Various keywords are used to specify this statement: descendants of ALGOL use "for", while descendants of Fortran use "do". There are other possibilities, for example COBOL which uses "PERFORM VARYING".

A system programming language is a programming language used for system programming; such languages are designed for writing system software, which usually requires different development approaches when compared with application software. Edsger Dijkstra refers to these language as Machine Oriented High Order Languages, or mohol.

In computer programming, a thunk is a subroutine used to inject a calculation into another subroutine. Thunks are primarily used to delay a calculation until its result is needed, or to insert operations at the beginning or end of the other subroutine. They have many other applications in compiler code generation and modular programming.

In computer programming, operators are constructs defined within programming languages which behave generally like functions, but which differ syntactically or semantically.

The history of programming languages spans from documentation of early mechanical computers to modern tools for software development. Early programming languages were highly specialized, relying on mathematical notation and similarly obscure syntax. Throughout the 20th century, research in compiler theory led to the creation of high-level programming languages, which use a more accessible syntax to communicate instructions.

In computer programming, a statement is a syntactic unit of an imperative programming language that expresses some action to be carried out. A program written in such a language is formed by a sequence of one or more statements. A statement may have internal components.

Edinburgh IMP is a development of Atlas Autocode, initially developed around 1966-1969 at the University of Edinburgh, Scotland. It is a general-purpose programming language which was used heavily for systems programming.

Extensible programming is a term used in computer science to describe a style of computer programming that focuses on mechanisms to extend the programming language, compiler and runtime environment. Extensible programming languages, supporting this style of programming, were an active area of work in the 1960s, but the movement was marginalized in the 1970s. Extensible programming has become a topic of renewed interest in the 21st century.

S-algol is a computer programming language derivative of ALGOL 60 developed at the University of St Andrews in 1979 by Ron Morrison and Tony Davie. The language is a modification of ALGOL to contain orthogonal data types that Morrison created for his PhD thesis. Morrison would go on to become professor at the university and head of the department of computer science. The S-algol language was used for teaching at the university at an undergraduate level until 1999. It was also the language taught for several years in the 1980s at a local school in St. Andrews, Madras College. The computer science text Recursive Descent Compiling describes a recursive descent compiler for S-algol, implemented in S-algol.

The following outline is provided as an overview of and topical guide to computer programming:

The ECL programming language and system were an extensible high-level programming language and development environment developed at Harvard University in the 1970s. The name 'ECL' stood for 'Extensible Computer Language' or 'EClectic Language'. Some publications used the name 'ECL' for the entire system and 'EL/1' for the language itself.

In computing, a compiler is a computer program that transforms source code written in a programming language or computer language, into another computer language. The most common reason for transforming source code is to create an executable program.

References

↑ Cotter, George. "High-Performance Computing at the National Security Agency". Frontiers of Supercomputing II. University of California Press. Retrieved 25 May 2012.

Irons, Edgar T. (January 1970). "Experience with an Extensible Language". Communications of the ACM . Association for Computing Machinery. 13 (1): 31–40. doi:10.1145/361953.361966. S2CID 17635545.
Bilofsky, Walter (May 1974). "Syntax Extension and the IMP72 Programming Language". SIGPLAN Notices. Association for Computing Machinery. 9 (5): 13–30. doi:10.1145/987413.987416. S2CID 2170981 – via Yale University.

External links

PDP-10 IMP72 Reference Manual
IMP72 Sources (dcus:[43,50306]*.*)

This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.

[1] Cotter, George. "High-Performance Computing at the National Security Agency". Frontiers of Supercomputing II. University of California Press. Retrieved 25 May 2012.

[1]