Academia.eduAcademia.edu

Outline

Title
Abstract
Figures
References
All Topics
Computer Science

Away from the operations view of computer science

Profile image of Bill WadgeBill Wadge

Abstract

We argue that classical programming languages are based on a fundamentally mistaken emphasis on the operational aspect of computation. These languages are seen as the means by which the programmer brings about particular kinds of operational activity (such as procedure calling or message passing). We suggest an alternate philosophy which places the emphasis on static, extensional (mathematical) concepts such as that of function or sequence. We outline a simple functional language (Luswim) based on these principles. The Luswim programmer specifies the desired output, and operational concepts such as dataflow, message passing or coroutine linkage can be used to 'evaluate' the specification. Operational activity occupies its proper place, namely as means to an end rather than an end in itself.

Figures (1)
Next we present a program in which we ‘abstract’ this block into a function and then use it Then in implementing programs like these we treat the body of a function definition like that of avg as a template, calls of which produce separate instances each with their own copies of the private local variables. Notice that this is not the same as an Algol procedure with local own variables—when (as above) the function is used in two different places, the internal values corresponding to different calls would get tangled up with each other, as a result of which we would get the wrong answer. The variables N and S are local to the prodof phrase but the phrase cannot be understod operationally as an Algol block, because we must imagine that their values are kept around from one ‘invocation’ to the next (N is a counter, and S keeps a running total of the values of X so far). Instead, we have to see it as a continuously operating “process” or “actor” with local memory, repeatedly taking in values of X and repeatedly producing (hence “prodof”, not “valof”) corresponding values of Y.
Next we present a program in which we ‘abstract’ this block into a function and then use it Then in implementing programs like these we treat the body of a function definition like that of avg as a template, calls of which produce separate instances each with their own copies of the private local variables. Notice that this is not the same as an Algol procedure with local own variables—when (as above) the function is used in two different places, the internal values corresponding to different calls would get tangled up with each other, as a result of which we would get the wrong answer. The variables N and S are local to the prodof phrase but the phrase cannot be understod operationally as an Algol block, because we must imagine that their values are kept around from one ‘invocation’ to the next (N is a counter, and S keeps a running total of the values of X so far). Instead, we have to see it as a continuously operating “process” or “actor” with local memory, repeatedly taking in values of X and repeatedly producing (hence “prodof”, not “valof”) corresponding values of Y.

Related papers

Operational machine specification in a functional programming language
Pieter Koopman

Software: Practice and Experience, 1995

This paper advocates the use of a functional programming language for the formal specification of (abstract) machines. The presented description method describes machines at two levels. At the bottom layer machine components and micro instructions to handle them are described by an abstract data type. The top layer describes the machine instructions in terms of these micro instructions.

View PDFchevron_right
Straight to the heart of computer science via functional programming
Ralf Hinze

1999

Abstract We outline a deductive concept for an introductory course to computer science aimed at CS students as well as students from other disciplines. The emphasis is on introducing fundamental concepts of computer science and showing how they evolve from each other. Functional programming in Haskell is used as a vehicle to explain these concepts and to allow for practical exercises. We argue that functional programming is more than just a good option for such an introductory course.

View PDFchevron_right
The implementation of functional programming languages
Malcolm Shute

Microprocessors and Microsystems, 1987

View PDFchevron_right
Implementation and Application of Functional Languages
Frank Huch

Springer eBooks, 2007

The version in the Kent Academic Repository may differ from the final published version. Users are advised to check for the status of the paper. Users should always cite the published version of record.

View PDFchevron_right
The Anatomy of Functional Programning in Java
Fernando Camutari MSc/EngTech/CEng/MBCS/MIEEE

Programming is an art that enables, one to elaborate or instruct ones aim to compute specific facets. The adoption of functional programming as a mainstream language is a challenge. However, with great rewards. Functional programming defines the concepts of problems that one rationalises for developing robust, scalable as well as for example concurrent systems. This research study, considers the following: why is functional programming the future for software engineering? And why is functional programming, receiving more attention than mainstream languages such as C++ and others.

View PDFchevron_right
DFL: A Data Flow Language
L M Patnaik

Computer Languages, 1984

Many novel computer architectures like array and multiprocessors which achieve high performance through the use of concurrency exploit variations of the von Neumann model of computation. The effective utilization of the machines makes special demands on programmers and their programming languages, such as the structuring of data into vectors or the partitioning of programs into concurrent processes. In comparison, the data flow model of computation demands only that the principle of structured programming be followed. A data flow program, often represented as a data flow graph, is a program that expresses a computation by indicating the data dependencies among operators. A data flow computer is a machine designed to take advantage of concurrency in data flow graphs by executing data independent operations in parallel. In this paper, we discuss the design of a high level language (DFL: Data Flow Language) suitable for data flow computers. Some sample procedures in DFL are presented. The implementation aspects have not been discussed in detail since there are no new problems encountered. The language DFL embodies the concepts of functional programming, but in appearance closely resembles Pascal. The language is a better vehicle than the data flow graph for expressing a parallel algorithm. The compiler has been implemented on a DEC 1090 system in Pascal.

View PDFchevron_right
Semantics of Programming Languages
Alberto Pettorossi

2016

In these lecture notes we present a few basic approaches to the definition of the semantics of programming languages. In particular, we present: (i) the operational semantics and the axiomatic semantics for a simple imperative language, and (ii) the operational semantics and the denotational semantics for some first order and higher order, typed functional languages. We then present some basic techniques for proving properties of imperative, functional, and concurrent programs. We closely follow the presentation done in the book by Glynn Winskel [19]. I express my gratitude to my colleagues at the Department of Informatics, Systems, and Production of the University of Roma Tor Vergata, and to my students and my co-workers Fabio Fioravanti, Fulvio Forni, Maurizio Proietti, and Valerio Senni for their support and encouragement. Thanks to Michele Ranieri and Massimiliano Macchia for pointing out some imprecisions in a preliminary version of these lecture notes. Many thanks also to the Aracne Publishing Company for its helpful cooperation.

View PDFchevron_right
Understanding programming language concepts via operational semantics
Cliff Jones

2007

The origins of “formal methods” lie partly in language description (although applications of methods like VDM, RAISE or B to areas other than programming languages are probably more widely known). This paper revisits the language description task but uses operational (rather than denotational) semantics to illustrate that the crucial idea is thinking about an abstract model of something that one is trying to understand or design.

View PDFchevron_right
The Sisal model of functional programming and its implementation
Walid Najjar

Proceedings of IEEE International Symposium on Parallel Algorithms Architecture Synthesis, 1997

Programming massively-parallel machine is a daunting task for any human programmer and parallelization may even be impossible for any compiler. Instead, the functional programming paradigm may prove to be an ideal solution by providing an implicitly parallel interface to the programmer. We describe here the Sisal project (Stream and Iteration in a Single Assignment Language) and its goal to provide a general-purpose user interface for a wide range of parallel processing platforms.

View PDFchevron_right
FACILE: A symmetric integration of concurrent and functional programming
Alessandro Giacalone

Lecture Notes in Computer Science, 1989

FACILE is a language which symmetrically integrates concurrent and functional programming. It is a typed and statically scoped language. The language supports both function and process abstractions.

View PDFchevron_right

References (6)

  1. Edward A. Ashcroft and William W. Wadge. Lucid, a nonprocedural language with iteration. Commun. ACM, 20(7):519-526, 1977. http://doi.acm.org/10.1145/359636.359715.
  2. Edward A. Ashcroft and William W. Wadge. Clauses: Scope structures and defined functions in Lucid. In POPL, pages 17-22, 1978.
  3. Gilles Kahn. The semantics of simple language for parallel programming. In IFIP Congress, pages 471-475, 1974.
  4. Robert A. Kowalski. Predicate logic as programming language. In IFIP Congress, pages 569-574, 1974.
  5. Peter J. Landin. The next 700 programming languages. Commun. ACM, 9(3):157-166, 1966.
  6. Jean Vuillemin. Correct and optimal implementations of recursion in a simple programming language. J. Comput. Syst. Sci., 9(3):332-354, 1974.

Related papers

The implementation of functional languages on an object-oriented architecture
Mohammed Y Khan

1993

for their invaluable support, encouragement and guidance given at all times throughout the duration of this project. A special thanks for their keen interest in the development of the project, without which this research would not be possible. The author is greatly indebted to his external advisors Mr. G. Michaelson and Professor D. M. Harland for their valuable advice received on various aspects of the investigation. The author would also like to thanks the reviewers, who suggested many im provements to this thesis, including the addition of several interesting experiments, with special thanks to P. I. Dugard for her valuable advice on statistical analysis. Thanks to the technical staff, in particular Mr J. Duncan for his assistance in the Laboratory. m A bstract This thesis concerns the investigation of different implementation strategies for functional languages on a novel platform, the Rekursiv, that provides hardware sup port for an object-oriented language (Lingo) which was used as the implementation language for this work. The objective is to evaluate the performance of two different implementation techniques-fixed combinators and supercombinators-for functional languages byinterpreting the functional program in two object-oriented styles with different rep resentations for combinators on two different environments: • A purpose-built object-oriented machine; Harland's Rekursiv. • A RISC machine; an IBM RS6000 running a Smalltalk-80 interpreter. Interpreters are implemented in Smalltalk (for the RS6000) and Lingo (for the Rekursiv) for an applicative language Alcal (a A-calculus language). The interpreters are then used to generate a combinator graph using the fixed SKI set of combinators proposed by Turner, and also Hughes-style program specific supercombinators (Alifting) which are not limited to a fixed set of primitive combinators. A number of experiments are conducted, based on the implementation of the lazy functional language, Alcal, on the RS6000 in Smalltalk-80 and on the Rekursiv architecture in Lingo. Lingo and Smalltalk allow the creation of objects that con tain executable statements, so an object-oriented 'active graph' implementation is proposed. Using these prototypes, the performance of the Rekursiv implementation against the RISC implementation has been evaluated. This includes the proportion of time spent on overhead activities and a statistical performance analysis of the bench mark results to analyse some of the claims made by the designer of the Rekursiv architecture. IV Relative to a baseline benchmark written in C, the implementations on the Rekursiv are found to be several times faster than those on the RISC machine. An analysis of variance demonstrates a more subtle interplay between benchmark programs, implementation techniques, representation of combinators and hardware platform.

View PDFchevron_right
An intensional implementation technique for functional languages
Ali Yaghi

1984

The potential of functional programming languages has not been widely accepted yet. The reason lies in the difficulties associated with their implementation. In this dissertation we propose a new implementation technique for functional languages by compiling them into 'Intensional Logic' of R. Montague and R. Carnap. Our technique is not limited to a particular hardware or to a particular evaluation strategy; nevertheless it lends itself directly to demand-driven tagged dataflow architecture. Even though our technique can handle conventional languages as well, our main interest is exclusively with functional languages in general and with Lucid-like dataflow languages in particular. We give a brief general account of intensional logic and then introduce the concept of intensional algebras as structures (models) for intensional logic. We, formally, show the computability requirements for such algebras. The target language of our compilation is the family of languages DE (defin...

View PDFchevron_right
The Imperative and Functional Programming Paradigm
Rinus Plasmeijer, Henk Barendregt

Computability via Turing machines gave rise to Imperative Programming. Computability described via λ-calculus gave rise to Functional Programming. As imperative programs are more easy to run on hardware, this style of software became predominant. We present major advantages of the functional programming paradigm over the imperative one, that are applicable, provided one is has the mental capacity to explicitly deal with simple abstractions.

View PDFchevron_right
Fundamentals, Prospects and Challenges for Totally Functional Programming Style
paul bailes

2014

General recursive definitions contribute to the complexity of programming. This complexity could be reduced by reliance on established, well-understood programming patterns. Catamorphism-based recursion patterns simplify programming with little practical loss in expressive capability compared to general recursion, including the capability of defining new recursion patterns. Partial application of catamorphisms, sub-catamorphic recursion patterns and methods to symbolic data allows a comprehensive replacement of symbolic data with functional, or what we describe as “zoetic”, representations that inherently adopt the benefits of catamorphism-based programming. The considerable promise of this “Totally Functional” style confronts us with some exciting technical challenges. Keywords-component; Catamorphism, Fold, Functional, Recursion.

View PDFchevron_right
Implementation of Functional Languages
Pieter Koopman

Lecture Notes in Computer Science, 2000

The version in the Kent Academic Repository may differ from the final published version. Users are advised to check http://kar.kent.ac.uk for the status of the paper. Users should always cite the published version of record.

View PDFchevron_right

Related topics

  • Computer Science
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved