GEDANKEN—a simple typeless language based on the principle of completeness and the reference concept
TL;DR: The functional approach to data structures and the use of references insure that any process which accepts some data structure will accept any logically equivalent structure, regardless of its internal representation.
Abstract: GEDANKEN is an experimental programming language with the following characteristics. (1) Any value which is permitted in some context of the language is permissible in any other meaningful context. In particular, functions and labels are permissible results of functions and values of variables. (2) Assignment and indirect addressing are formalized by introducing values, called references, which in turn possess other values. The assignment operation always affects the relation between some reference and its value. (3) All compound data structures are treated as functions. (4) Type declarations are not permitted. The functional approach to data structures and the use of references insure that any process which accepts some data structure will accept any logically equivalent structure, regardless of its internal representation. More generally, any data structure may be implicit; i.e. it may be specified by giving an arbitrary algorithm for computing or accessing its components. The existence of label variables permits the construction of co-routines, quasi-parallel processes, and other unorthodox control mechanisms. A variety of programming examples illustrates the generality of the language. Limitations and possible extensions are discussed briefly.
Citations
More filters
IBM1
TL;DR: A new class of computing systems uses the functional programming style both in its programming language and in its state transition rules; these systems have semantics loosely coupled to states—only one state transition occurs per major computation.
Abstract: Conventional programming languages are growing ever more enormous, but not stronger. Inherent defects at the most basic level cause them to be both fat and weak: their primitive word-at-a-time style of programming inherited from their common ancestor—the von Neumann computer, their close coupling of semantics to state transitions, their division of programming into a world of expressions and a world of statements, their inability to effectively use powerful combining forms for building new programs from existing ones, and their lack of useful mathematical properties for reasoning about programs.An alternative functional style of programming is founded on the use of combining forms for creating programs. Functional programs deal with structured data, are often nonrepetitive and nonrecursive, are hierarchically constructed, do not name their arguments, and do not require the complex machinery of procedure declarations to become generally applicable. Combining forms can use high level programs to build still higher level ones in a style not possible in conventional languages.Associated with the functional style of programming is an algebra of programs whose variables range over programs and whose operations are combining forms. This algebra can be used to transform programs and to solve equations whose “unknowns” are programs in much the same way one transforms equations in high school algebra. These transformations are given by algebraic laws and are carried out in the same language in which programs are written. Combining forms are chosen not only for their programming power but also for the power of their associated algebraic laws. General theorems of the algebra give the detailed behavior and termination conditions for large classes of programs.A new class of computing systems uses the functional programming style both in its programming language and in its state transition rules. Unlike von Neumann languages, these systems have semantics loosely coupled to states—only one state transition occurs per major computation.
2,651 citations
TL;DR: This paper examines the old question of the relationship between ISWIM and the λ-calculus, using the distinction between call-by-value and call- by-name, and finds that operational equality is not preserved by either of the simulations.
1,240 citations
TL;DR: A light sensing apparatus is described which employs a GaAsP MOS light-receiving element to which a potential is applied for creating a depletion region.
1,062 citations
01 Aug 1972
TL;DR: The definition of a simple applicative programming language by means of an interpreter written in a similar language is considered, and the treatment of imperative features such as jumps and assignment is discussed.
Abstract: Higher-order programming languages (i.e., languages in which procedures or labels can occur as values) are usually defined by interpreters which are themselves written in a programming language based on the lambda calculus (i.e., an applicative language such as pure LISP). Examples include McCarthy's definition of LISP, Landin's SECD machine, the Vienna definition of PL/I, Reynolds' definitions of GEDANKEN, and recent unpublished work by L. Morris and C. Wadsworth. Such definitions can be classified according to whether the interpreter contains higher-order functions, and whether the order of application (i.e., call-by-value versus call-by-name) in the defined language depends upon the order of application in the defining language. As an example, we consider the definition of a simple applicative programming language by means of an interpreter written in a similar language. Definitions in each of the above classifications are derived from one another by informal but constructive methods. The treatment of imperative features such as jumps and assignment is also discussed.
743 citations
Cites background or methods from "GEDANKEN—a simple typeless language..."
..., they can be defined as abbreviations for expressions in the restricted language [7, 4]....
[...]
...Key Words and Phrases: programming language, language definition, interpreter, lambda calculus, applicative language, higher-order function, closure, order of appli- cation, continuation, LISP, GEDANKEN, PAL, SECD machine, J-operator, reference....
[...]
...These two criteria establish four possible classes of interpreters, each of which contains one or more of the examples cited earlier: Order-of Use of hi~her-order functions: application dependence yes no yes direct interpreter McCarthy's for GEDANKEN definition of LISP no Morris-Wadsworth SECD machine method Vienna definition The main goal of this paper is to illustrate and relate these classes of definitional interpreters....
[...]
...However, the unrestricted use of procedures and labels as data is permitted in only a handful of languages which sacrifice efficiency for generality: LISP (in most of its interpretive implementations), ISWIM, PAL, GEDANKEN, and (roughly) POP-2....
[...]
...This approach is used in ALGOL 68, (23) BASIL,(27) and GEDANKEN....
[...]
IBM1
TL;DR: Combining forms can be used to transform programs and solve equations whose unknowns are programs in much the same way one tranforms equations in high school algebra as discussed by the authors, which is an algebra of programs whose variables range over programs and whose operations are combining forms.
Abstract: Conventional programming languages are growing ever more enormous, but not stronger. Inherent defects at the most basic level cause them to be both fat and weak: their primitive word-at-a-time style of programming inherited from their common ancestor--the yon Neumann computer, their close coupling of semantics to state transitions, their division of programming into a world of expressions and a world of statements, their inability to effectively use powerful combining forms for building new programs from existing ones, and their lack of useful mathematical properties for reasoning about programs.An alternative functional style of programming is founded on the use of combining forms for creating programs. Functional programs deal with structured data, are often nonrepetitive and nonrecursive, are hierarchically constructed, do not name their arguments, and do not require the complex machinery of procedure declarations to become generally applicable. Combining forms can use high-level programs to build still higher level ones in a style not possible in conventional languages.Associated with the functional style of programming is an algebra of programs whose variables range over programs and whose operations are combining forms. This algebra can be used to transform programs and to solve equations whose "unknowns" are programs in much the same way one tranforms equations in high school algebra. These transformations are given by algebraic laws and are carried out in the same language in which programs are written. Combining forms are chosen not only for their programming power but also the power of their associated algebraic laws. General theorems of the algebra give the detailed behavior and termination conditions for large classes of programs.A new class of computing systems uses the functional programming style both in its programming language and in its stage transition rules. Unlike von Neumann languages, these systems have semantics loosely coupled to states --- only one state transition occurs per major computation.
354 citations
References
More filters
TL;DR: In this article, a parsing algorithm which seems to be the most efficient general context-free algorithm known is described, which is similar to both Knuth's LR(k) algorithm and the familiar top-down algorithm.
Abstract: A parsing algorithm which seems to be the most efficient general context-free algorithm known is described. It is similar to both Knuth's LR(k) algorithm and the familiar top-down algorithm. It has a time bound proportional to n3 (where n is the length of the string being parsed) in general; it has an n2 bound for unambiguous grammars; and it runs in linear time on a large class of grammars, which seems to include most practical context-free programming language grammars. In an empirical comparison it appears to be superior to the top-down and bottom-up algorithms studied by Griffiths and Petrick.
1,516 citations
TL;DR: A programming system called LISP (for LISt Processor) developed for the IBM 704 computer by the Artificial Intelligence group at M.I.T. was designed to facilitate experiments with a proposed system called the Advice Taker, whereby a machine could be instructed to handle declarative as well as imperative sentences and could exhibit "common sense" in carrying out its instructions.
Abstract: A programming system called LISP (for LISt Processor) has been developed for the IBM 704 computer by the Artificial Intelligence group at M.I.T. The system was designed to facilitate experiments with a proposed system called the Advice Taker, whereby a machine could be instructed to handle declarative as well as imperative sentences and could exhibit “common sense” in carrying out its instructions. The original proposal [1] for the Advice Taker was made in November 1958. The main requirement was a programming system for manipulating expressions representing formalized declarative and imperative sentences so that the Advice Taker system could make deductions. In the course of its development the LISP system went through several stages of simplification and eventually came to be based on a scheme for representing the partial recursive functions of a certain class of symbolic expressions. This representation is independent of the IBM 704 computer, or of any other electronic computer, and it now seems expedient to expound the system by starting with the class of expressions called S-expressions and the functions called S-functions.
1,435 citations
TL;DR: This paper is an introduction to SIMULA, a programming language designed to provide a systems analyst with unified concepts which facilitate the concise description of discrete event systems.
Abstract: This paper is an introduction to SIMULA, a programming language designed to provide a systems analyst with unified concepts which facilitate the concise description of discrete event systems. A system description also serves as a source language simulation program. SIMULA is an extension of ALGOL 60 in which the most important new concept is that of quasi-parallel processing.
875 citations
TL;DR: A parsing algorithm which seems to be the most efficient general context-free algorithm known is described, similar to both Knuth's LR(k) algorithm and the familiar top-down algorithm.
Abstract: A parsing algorithm which seems to be the most efficient general context-free algorithm known is described. It is similar to both Knuth's LR(k) algorithm and the familiar top-down algorithm. It has...
873 citations
TL;DR: A family of unimplemented computing languages is described that is intended to span differences of application area by a unified framework that dictates the rules about the uses of user-coined names, and the conventions about characterizing functional relationships.
Abstract: A family of unimplemented computing languages is described that is intended to span differences of application area by a unified framework. This framework dictates the rules about the uses of user-coined names, and the conventions about characterizing functional relationships. Within this framework the design of a specific language splits into two independent parts. One is the choice of written appearances of programs (or more generally, their physical representation). The other is the choice of the abstract entities (such as numbers, character-strings, list of them, functional relations among them) that can be referred to in the language.The system is biased towards “expressions” rather than “statements.” It includes a nonprocedural (purely functional) subsystem that aims to expand the class of users' needs that can be met by a single print-instruction, without sacrificing the important properties that make conventional right-hand-side expressions easy to construct and understand.
637 citations
"GEDANKEN—a simple typeless language..." refers background or methods in this paper
...Landin [ 2 ] and Evans [3] in dividing the language into an applicative part, involving the evaluation of expressions and the application of functions, and an imperative part, involving assignment and control jumps....
[...]
...LISP [la and lb] (in its interpretive implementations), IswIM [ 2 ], and PAL [3] all satisfy the principle of completeness, and the reference concept is used in ALGOL 68 [4] and BASEL [5]....
[...]