Resource-passing concurrent programming

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

    10 Citations (Scopus)

    Abstract

    The use of types to deal with access capabilities of program entities is becoming increasingly popular. In concurrent logic programming, the first attempt was made in Moded Flat GHC in 1990, which gave polarity structures (modes) to every variable occurrence and every predicate argument. Strong moding turned out to play fundamental rôles in programming, implementation and the in-depthunderstanding of constraint-based concurrent computation. The moding principle guarantees that each variable is written only once and encourages capability-conscious programming. Furthermore, it gives less generic modes to programs that discard or duplicate data, thus providing the view of "data as resources." A simple linearity system built upon the mode system distinguishes variables read only once from those read possibly many times, enabling compile-time garbage collection. Compared to linear types studied in other programming paradigms, the primary issue in constraint-based concurrency has been to deal with logical variables and highly non-strict data structures they induce. In this paper, we put our resource-consciousness one step forward and consider a class of 'ecological' programs which recycle or return all the resources given to them while allowing concurrent reading of data structures via controlled aliasing. This completely recyclic subset enforces us to think more about resources, but the resulting programs enjoy high symmetry which we believe has more than aesthetic implications to our programming practice in general. The type system supporting recyclic concurrent programming gives a [−1,+1] capability to eachoccurrence of variable and function symbols (constructors), where positive/negative values mean read/write capabilities, respectively, and fractions mean non-exclusive read/write paths. The capabilities are intended to be statically checked or reconstructed so that one can tell the polarity and exclusiveness of each piece of information handled by concurrent processes. The capability type system refines and integrates the mode system and the linearity system for Moded Flat GHC. Its arithmetic formulation contributes to the simplicity. The execution of a recyclic program proceeds so that every variable has zero-sum capability and the resources (i.e., constructors weighted by their capabilities) a process absorbs match the resources it emits. Constructors accessed by a process withan exclusive read capability can be reused for other purposes. The first half of this paper is devoted to a tutorial introduction to constraint-based concurrency in the hope that it will encourage crossfertilization of different concurrency formalisms.

    Original languageEnglish
    Title of host publicationTheoretical Aspects of Computer Software - 4th International Symposium, TACS 2001, Proceedings
    PublisherSpringer Verlag
    Pages95-126
    Number of pages32
    Volume2215
    ISBN (Print)3540427368, 9783540427360
    Publication statusPublished - 2001
    Event4th International Symposium on Theoretical Aspects of Computer Software, TACS 2001 - Sendai, Japan
    Duration: 2001 Oct 292001 Oct 31

    Publication series

    NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
    Volume2215
    ISSN (Print)03029743
    ISSN (Electronic)16113349

    Other

    Other4th International Symposium on Theoretical Aspects of Computer Software, TACS 2001
    CountryJapan
    CitySendai
    Period01/10/2901/10/31

    Fingerprint

    Concurrent Programming
    Data structures
    Resources
    Logic programming
    Programming
    Concurrency
    Concurrent
    Polarity
    Type Systems
    Linearity
    Data Structures
    Garbage Collection
    Zero-sum
    Aliasing
    Logic Programming
    Mean Value
    Predicate
    Simplicity
    Paradigm
    Integrate

    ASJC Scopus subject areas

    • Computer Science(all)
    • Theoretical Computer Science

    Cite this

    Ueda, K. (2001). Resource-passing concurrent programming. In Theoretical Aspects of Computer Software - 4th International Symposium, TACS 2001, Proceedings (Vol. 2215, pp. 95-126). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 2215). Springer Verlag.

    Resource-passing concurrent programming. / Ueda, Kazunori.

    Theoretical Aspects of Computer Software - 4th International Symposium, TACS 2001, Proceedings. Vol. 2215 Springer Verlag, 2001. p. 95-126 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 2215).

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

    Ueda, K 2001, Resource-passing concurrent programming. in Theoretical Aspects of Computer Software - 4th International Symposium, TACS 2001, Proceedings. vol. 2215, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 2215, Springer Verlag, pp. 95-126, 4th International Symposium on Theoretical Aspects of Computer Software, TACS 2001, Sendai, Japan, 01/10/29.
    Ueda K. Resource-passing concurrent programming. In Theoretical Aspects of Computer Software - 4th International Symposium, TACS 2001, Proceedings. Vol. 2215. Springer Verlag. 2001. p. 95-126. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
    Ueda, Kazunori. / Resource-passing concurrent programming. Theoretical Aspects of Computer Software - 4th International Symposium, TACS 2001, Proceedings. Vol. 2215 Springer Verlag, 2001. pp. 95-126 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
    @inproceedings{421793bc78d64214a20e595ec7333624,
    title = "Resource-passing concurrent programming",
    abstract = "The use of types to deal with access capabilities of program entities is becoming increasingly popular. In concurrent logic programming, the first attempt was made in Moded Flat GHC in 1990, which gave polarity structures (modes) to every variable occurrence and every predicate argument. Strong moding turned out to play fundamental r{\^o}les in programming, implementation and the in-depthunderstanding of constraint-based concurrent computation. The moding principle guarantees that each variable is written only once and encourages capability-conscious programming. Furthermore, it gives less generic modes to programs that discard or duplicate data, thus providing the view of {"}data as resources.{"} A simple linearity system built upon the mode system distinguishes variables read only once from those read possibly many times, enabling compile-time garbage collection. Compared to linear types studied in other programming paradigms, the primary issue in constraint-based concurrency has been to deal with logical variables and highly non-strict data structures they induce. In this paper, we put our resource-consciousness one step forward and consider a class of 'ecological' programs which recycle or return all the resources given to them while allowing concurrent reading of data structures via controlled aliasing. This completely recyclic subset enforces us to think more about resources, but the resulting programs enjoy high symmetry which we believe has more than aesthetic implications to our programming practice in general. The type system supporting recyclic concurrent programming gives a [−1,+1] capability to eachoccurrence of variable and function symbols (constructors), where positive/negative values mean read/write capabilities, respectively, and fractions mean non-exclusive read/write paths. The capabilities are intended to be statically checked or reconstructed so that one can tell the polarity and exclusiveness of each piece of information handled by concurrent processes. The capability type system refines and integrates the mode system and the linearity system for Moded Flat GHC. Its arithmetic formulation contributes to the simplicity. The execution of a recyclic program proceeds so that every variable has zero-sum capability and the resources (i.e., constructors weighted by their capabilities) a process absorbs match the resources it emits. Constructors accessed by a process withan exclusive read capability can be reused for other purposes. The first half of this paper is devoted to a tutorial introduction to constraint-based concurrency in the hope that it will encourage crossfertilization of different concurrency formalisms.",
    author = "Kazunori Ueda",
    year = "2001",
    language = "English",
    isbn = "3540427368",
    volume = "2215",
    series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
    publisher = "Springer Verlag",
    pages = "95--126",
    booktitle = "Theoretical Aspects of Computer Software - 4th International Symposium, TACS 2001, Proceedings",
    address = "Germany",

    }

    TY - GEN

    T1 - Resource-passing concurrent programming

    AU - Ueda, Kazunori

    PY - 2001

    Y1 - 2001

    N2 - The use of types to deal with access capabilities of program entities is becoming increasingly popular. In concurrent logic programming, the first attempt was made in Moded Flat GHC in 1990, which gave polarity structures (modes) to every variable occurrence and every predicate argument. Strong moding turned out to play fundamental rôles in programming, implementation and the in-depthunderstanding of constraint-based concurrent computation. The moding principle guarantees that each variable is written only once and encourages capability-conscious programming. Furthermore, it gives less generic modes to programs that discard or duplicate data, thus providing the view of "data as resources." A simple linearity system built upon the mode system distinguishes variables read only once from those read possibly many times, enabling compile-time garbage collection. Compared to linear types studied in other programming paradigms, the primary issue in constraint-based concurrency has been to deal with logical variables and highly non-strict data structures they induce. In this paper, we put our resource-consciousness one step forward and consider a class of 'ecological' programs which recycle or return all the resources given to them while allowing concurrent reading of data structures via controlled aliasing. This completely recyclic subset enforces us to think more about resources, but the resulting programs enjoy high symmetry which we believe has more than aesthetic implications to our programming practice in general. The type system supporting recyclic concurrent programming gives a [−1,+1] capability to eachoccurrence of variable and function symbols (constructors), where positive/negative values mean read/write capabilities, respectively, and fractions mean non-exclusive read/write paths. The capabilities are intended to be statically checked or reconstructed so that one can tell the polarity and exclusiveness of each piece of information handled by concurrent processes. The capability type system refines and integrates the mode system and the linearity system for Moded Flat GHC. Its arithmetic formulation contributes to the simplicity. The execution of a recyclic program proceeds so that every variable has zero-sum capability and the resources (i.e., constructors weighted by their capabilities) a process absorbs match the resources it emits. Constructors accessed by a process withan exclusive read capability can be reused for other purposes. The first half of this paper is devoted to a tutorial introduction to constraint-based concurrency in the hope that it will encourage crossfertilization of different concurrency formalisms.

    AB - The use of types to deal with access capabilities of program entities is becoming increasingly popular. In concurrent logic programming, the first attempt was made in Moded Flat GHC in 1990, which gave polarity structures (modes) to every variable occurrence and every predicate argument. Strong moding turned out to play fundamental rôles in programming, implementation and the in-depthunderstanding of constraint-based concurrent computation. The moding principle guarantees that each variable is written only once and encourages capability-conscious programming. Furthermore, it gives less generic modes to programs that discard or duplicate data, thus providing the view of "data as resources." A simple linearity system built upon the mode system distinguishes variables read only once from those read possibly many times, enabling compile-time garbage collection. Compared to linear types studied in other programming paradigms, the primary issue in constraint-based concurrency has been to deal with logical variables and highly non-strict data structures they induce. In this paper, we put our resource-consciousness one step forward and consider a class of 'ecological' programs which recycle or return all the resources given to them while allowing concurrent reading of data structures via controlled aliasing. This completely recyclic subset enforces us to think more about resources, but the resulting programs enjoy high symmetry which we believe has more than aesthetic implications to our programming practice in general. The type system supporting recyclic concurrent programming gives a [−1,+1] capability to eachoccurrence of variable and function symbols (constructors), where positive/negative values mean read/write capabilities, respectively, and fractions mean non-exclusive read/write paths. The capabilities are intended to be statically checked or reconstructed so that one can tell the polarity and exclusiveness of each piece of information handled by concurrent processes. The capability type system refines and integrates the mode system and the linearity system for Moded Flat GHC. Its arithmetic formulation contributes to the simplicity. The execution of a recyclic program proceeds so that every variable has zero-sum capability and the resources (i.e., constructors weighted by their capabilities) a process absorbs match the resources it emits. Constructors accessed by a process withan exclusive read capability can be reused for other purposes. The first half of this paper is devoted to a tutorial introduction to constraint-based concurrency in the hope that it will encourage crossfertilization of different concurrency formalisms.

    UR - http://www.scopus.com/inward/record.url?scp=84979088530&partnerID=8YFLogxK

    UR - http://www.scopus.com/inward/citedby.url?scp=84979088530&partnerID=8YFLogxK

    M3 - Conference contribution

    SN - 3540427368

    SN - 9783540427360

    VL - 2215

    T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

    SP - 95

    EP - 126

    BT - Theoretical Aspects of Computer Software - 4th International Symposium, TACS 2001, Proceedings

    PB - Springer Verlag

    ER -