research-article

Open access

Manifest sharing with session types

Authors:

Stephanie Balzer,

Frank PfenningAuthors Info & Claims

Proceedings of the ACM on Programming Languages, Volume 1, Issue ICFP

Article No.: 37, Pages 1 - 29

https://doi.org/10.1145/3110281

Published: 29 August 2017 Publication History

Abstract

Session-typed languages building on the Curry-Howard isomorphism between linear logic and session-typed communication guarantee session fidelity and deadlock freedom. Unfortunately, these strong guarantees exclude many naturally occurring programming patterns pertaining to shared resources. In this paper, we introduce sharing into a session-typed language where types are stratified into linear and shared layers with modal operators connecting the layers. The resulting language retains session fidelity but not the absence of deadlocks, which can arise from contention for shared processes. We illustrate our language on various examples, such as the dining philosophers problem, and provide a translation of the untyped asynchronous π-calculus into our language.

References

[1]

Rob Arnold. 2010. C 0, an Imperative Programming Language for Novice Computer Scientists. Master’s thesis. Department of Computer Science, Carnegie Mellon University. Available as Technical Report CMU-CS-10-145.

[2]

Robert Atkey, Sam Lindley, and J. Garrett Morris. 2016. Conflation Confers Concurrency. In Wadler Festschrift, S. Lindley et al. (Ed.). Springer LNCS 9600, 32–55.

[3]

Stephanie Balzer and Frank Pfenning. 2017. Manifest Sharing with Session Types. Technical Report CMU-CS-17-106. Carnegie Mellon University.

[4]

Romain Beauxis, Catuscia Palamidessi, and Frank D. Valencia. 2008. On the Asynchronous Nature of the Asynchronous π -calculus. In Concurrency, Graphs and Models (Lecture Notes in Computer Science), Vol. 5065. Springer, 473–492.

Digital Library

[5]

P. N. Benton. 1994. A Mixed Linear and Non-Linear Logic: Proofs, Terms and Models. In 8th International Workshop on Computer Science Logic (CSL) (Lecture Notes in Computer Science), Vol. 933. Springer, 121–135. An extended version appeared as Technical Report UCAM-CL-TR-352, University of Cambridge.

[6]

Kevin Bierhoff and Jonathan Aldrich. 2007. Modular Typestate Checking of Aliased Objects. In 22nd Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA’07). ACM, 301–320.

Digital Library

[7]

John Boyland. 2003. Checking Interference with Fractional Permissions. In 10th International Symposium on Static Analysis (SAS). 55–72.

[8]

Stephen D. Brookes. 2004. A Semantics for Concurrent Separation Logic. In 15th International Conference on Concurrency Theory (CONCUR) (Lecture Notes in Computer Science), Vol. 3170. Springer, 16–34.

[9]

Luís Caires and Frank Pfenning. 2010. Session Types as Intuitionistic Linear Propositions. In 21st International Conference on Concurrency Theory (CONCUR) (Lecture Notes in Computer Science), Vol. 6269. Springer, 222–236.

[10]

Luís Caires, Frank Pfenning, and Bernardo Toninho. 2016. Linear Logic Propositions as Session Types. Mathematical Structures in Computer Science 26, 3 (2016), 367–423.

[11]

Elias Castegren and Tobias Wrigstad. 2017. Relaxed Linear References for Lock-free Data Structures. In 31st European Conference on Object-Oriented Programming (ECOOP) (Leibniz International Proceedings in Informatics (LIPIcs)), Vol. 74. Schloss Dagstuhl – Leibniz-Zentrum fuer Informatik, 6:1–6:32.

[12]

Iliano Cervesato, Frank Pfenning, David Walker, and Kevin Watkins. 2002. A Concurrent Logical Framework II: Examples and Applications. Technical Report CMU-CS-02-102. Computer Science Department, Carnegie Mellon University. Revised May 2003.

[13]

Iliano Cervesato and Andre Scedrov. 2009. Relating State-Based and Process-Based Concurrency through Linear Logic. Information and Computation 207, 10 (2009), 1044–1077.

Digital Library

[14]

Bor-Yuh Evan Chang, Kaustuv Chaudhuri, and Frank Pfenning. 2003. A Judgmental Analysis of Linear Logic. Technical Report CMU-CS-03-131R. School of Computer Science, Carnegie Mellon University.

[15]

Karl Crary, Robert Harper, and Sidd Puri. 1999. What is a Recursive Module?. In ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). 50–63.

Digital Library

[16]

Robert DeLine and Manuel Fähndrich. 2004. Typestates for Objects. In 18th European Conference on Object-Oriented Programming (ECOOP) (Lecture Notes in Computer Science), Vol. 3086. Springer, 465–490.

[17]

Yuxin Deng, Robert J. Simmons, and Iliano Cervesato. 2016. Relating Reasoning Methodologies in Linear Logic and Process Algebra. Mathematical Structure in Computer Science 26, 5 (Jan. 2016), 868–906.

[18]

Henry DeYoung, Luís Caires, Frank Pfenning, and Bernardo Toninho. 2012. Cut Reduction in Linear Logic as Asynchronous Session-Typed Communication. In Proceedings of the 21st Conference on Computer Science Logic (CSL 2012), P. Cégielski and A. Durand (Eds.). Leibniz International Proceedings in Informatics, Fontainebleau, France, 228–242.

[19]

Mariangiola Dezani-Ciancaglini, Dimitris Mostrous, Nobuko Yoshida, and Sophia Drossopoulou. 2006. Session Types for Object-Oriented Languages. In 20th European Conference on Object-Oriented Programming (ECOOP) (Lecture Notes in Computer Science), Vol. 4067. Springer, 328–352.

Digital Library

[20]

Edsger W. Dijkstra. 1971–1973. Hierarchical Ordering of Sequential Processes. (1971–1973). EWD Manuscript 310.

[21]

Manuel Fähndrich and Robert DeLine. 2002. Adoption and Focus: Practical Linear Types for Imperative Programming. In ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, 13–24.

Digital Library

[22]

Cormac Flanagan and Shaz Qadeer. 2003. A Type and Effect System for Atomicity. In ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, 338–349.

Digital Library

[23]

Simon J. Gay and Malcolm Hole. 2005. Subtyping for Session Types in the π -Calculus. Acta Informatica 42, 2–3 (2005), 191–225.

[24]

David K. Gifford and John M. Lucassen. 1986. Integrating Functional and Imperative Programming. In LISP and Functional Programming. 28–38.

Digital Library

[25]

Jean-Yves Girard. 1987. Linear Logic. Theoretical Computer Science 50 (1987), 1–102.

Digital Library

[26]

Dennis Griffith. 2016. Polarized Substructural Session Types. Ph.D. Dissertation. University of Illinois at Urbana-Champaign.

[27]

Dennis Griffith and Frank Pfenning. 2015. SILL. https://github.com/ISANobody/sill . (2015).

[28]

Robert Harper. 2013. Practical Foundations for Programming Languages. Cambridge University Press.

[29]

Stefan Heule, K. Rustan M. Leino, Peter Müller, and Alexander J. Summers. 2013. Abstract Read Permissions: Fractional Permissions without the Fractions. In 14th International Conference on Verification, Model Checking, and Abstract Interpretation (VMCAI) (Lecture Notes in Computer Science), Vol. 7737. Springer, 315–334.

[30]

Kohei Honda. 1993. Types for Dyadic Interaction. In 4th International Conference on Concurrency Theory (CONCUR) (Lecture Notes in Computer Science), Vol. 715. Springer, 509–523.

[31]

Kohei Honda, Vasco T. Vasconcelos, and Makoto Kubo. 1998. Language Primitives and Type Discipline for Structured Communication-Based Programming. In 7th European Symposium on Programming (ESOP) (Lecture Notes in Computer Science), Vol. 1381. Springer, 122–138.

[32]

Kohei Honda, Nobuko Yoshida, and Marco Carbone. 2008. Multiparty Asynchronous Session Types. In 35th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, 273–284.

Digital Library

[33]

W. A. Howard. 1969. The Formulae-as-Types Notion of Construction. (1969). Unpublished note. An annotated version appeared in: To H.B. Curry: Essays on Combinatory Logic, Lambda Calculus and Formalism, 479–490, Academic Press (1980).

[34]

Raymond Hu, Nobuko Yoshida, and Kohei Honda. 2008. Session-Based Distributed Programming in Java. In 22nd European Conference on Object-Oriented Programming (ECOOP) (Lecture Notes in Computer Science), Vol. 5142. Springer, 516–541.

Digital Library

[35]

Thomas Bracht Laumann Jespersen, Philip Munksgaard, and Ken Friis Larsen. 2015. Session Types for Rust. In 11th ACM SIGPLAN Workshop on Generic Programming (WGP).

[36]

Limin Jia, Hannah Gommerstadt, and Frank Pfenning. 2016. Monitors and Blame Assignment for Higher-Order Session Types. In 43rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). 582–594.

Digital Library

[37]

Ralf Jung, David Swasey, Filip Sieczkowski, Kasper Svendsen, Aaron Turon, Lars Birkedal, and Derek Dreyer. 2015. Iris: Monoids and Invariants as an Orthogonal Basis for Concurrent Reasoning. In 42nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, 637–650.

Digital Library

[38]

Naoki Kobayashi and Cosimo Laneve. 2017. Deadlock Analysis of Unbounded Process Networks. Information and Computation 252 (2017), 48–70.

Digital Library

[39]

Julien Lange, Nicholas Ng, Bernardo Toninho, and Nobuko Yoshida. 2017. Fencing off Go: Liveness and Safety for ChannelBased Programming. In 44th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, 748–761.

Digital Library

[40]

K. Rustan M. Leino and Peter Müller. 2009. A Basis for Verifying Multi-Threaded Programs. In 18th European Symposium on Programming (ESOP). 378–393.

[41]

Damiano Mazza. 2016. The True Concurrency of Differential Interaction Nets. Mathematical Structures in Computer Science (11 2016), 1–29.

[42]

Filipe Militão, Jonathan Aldrich, and Luís Caires. 2014. Rely-Guarantee Protocols. In 28th European Conference on ObjectOriented Programming (ECOOP) (Lecture Notes in Computer Science), Vol. 8586. Springer, 334–359.

[43]

Robin Milner. 1999. Communicating and Mobile Systems: the π -Calculus. Cambridge University Press.

[44]

MozillaResearch. 2016. The Rust Programming Language. https://doc.rust- lang.org/stable/book . (November 2016).

[45]

Karl Naden, Robert Bocchino, Jonathan Aldrich, and Kevin Bierhoff. 2012. A Type System for Borrowing Permissions. In 39th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM, 557–570.

Digital Library

[46]

Rumyana Neykova and Nobuko Yoshida. 2014. Multiparty Session Actors. In 16th International Conference on Coordination Models and Languages (COORDINATION) (Lecture Notes in Computer Science), Vol. 8459. Springer, 131–146.

Digital Library

[47]

Ligia Nistor, Jonathan Aldrich, Stephanie Balzer, and Hannes Mehnert. 2014. Object Propositions. In 19th International Symposium on Formal Methods (FM) (Lecture Notes in Computer Science), Vol. 8442. Springer, 497–513.

Digital Library

[48]

Peter W. O’Hearn. 2004. Resources, Concurrency and Local Reasoning. In 15th International Conference on Concurrency Theory (CONCUR) (Lecture Notes in Computer Science), Vol. 3170. Springer, 49–67.

[49]

Jorge A. Pérez, Luís Caires, Frank Pfenning, and Bernardo Toninho. 2014. Linear Logical Relations and Observational Equivalences for Session-Based Concurrency. Information and Computation 239 (2014), 254–302.

Digital Library

[50]

Frank Pfenning. 2010. C0 Language. http://c0.typesafety.net. (2010).

[51]

Frank Pfenning, Thomas J. Cortina, and William Lovas. 2011. Teaching Imperative Programming With Contracts at the Freshmen Level. (2011). Unpublished note.

[52]

Frank Pfenning and Dennis Griffith. 2015. Polarized Substructural Session Types. In 18th International Conference on Foundations of Software Science and Computation Structures (FoSSaCS) (Lecture Notes in Computer Science), Vol. 9034. Springer, 3–22.

[53]

Jason Reed. 2009. A Judgmental Deconstruction of Modal Logic. (January 2009). http://www.cs.cmu.edu/~jcreed/papers/ jdml.pdf Unpublished manuscript.

[54]

Davide Sangiorgi and David Walker. 2001. The π -Calculus - A Theory of Mobile Processes. Cambridge University Press.

[55]

Alceste Scalas and Nobuko Yoshida. 2016. Lightweight Session Programming in Scala. In 30th European Conference on Object-Oriented Programming (ECOOP) (Leibniz International Proceedings in Informatics (LIPIcs)), Vol. 56. Schloss Dagstuhl – Leibniz-Zentrum fuer Informatik, 21:1–21:28.

[56]

Jan Smans, Bart Jacobs, and Frank Piessens. 2009. Implicit Dynamic Frames: Combining Dynamic Frames and Separation Logic. In 23rd European Conference on Object-Oriented Programming (ECOOP’09) (Lecture Notes in Computer Science), Vol. 5653. Springer, 148–172.

[57]

Frederick Smith, David Walker, and J. Gregory Morrisett. 2000. Alias Types. In 9th European Symposium on Programming (ESOP). 366–381.

[58]

Robert E. Strom and Shaula Yemini. 1986. Typestate: A Programming Language Concept for Enhancing Software Reliability. IEEE Transactions on Software Engineering (TSE) 12, 1 (1986), 157–171.

Digital Library

[59]

Bernardo Toninho. 2015. A Logical Foundation for Session-based Concurrent Computation. Ph.D. Dissertation. Carnegie Mellon University and New University of Lisbon.

[60]

Bernardo Toninho, Luís Caires, and Frank Pfenning. 2013. Higher-Order Processes, Functions, and Sessions: a Monadic Integration. In 22nd European Symposium on Programming (ESOP) (Lecture Notes in Computer Science), Vol. 7792. Springer, 350–369.

Digital Library

[61]

Aaron Turon, Derek Dreyer, and Lars Birkedal. 2013. Unifying Refinement and Hoare-Style Reasoning in a Logic for Higher-Order Concurrency. In 18th ACM SIGPLAN International Conference on Functional Programming (ICFP). ACM, 377–390.

Digital Library

[62]

Viktor Vafeiadis. 2011. Concurrent Separation Logic and Operational Semantics. Electronic Notes in Theoretical Computer Science 276 (2011), 335–351.

Digital Library

[63]

Philip Wadler. 1990. Linear Types Can Change the World!. In Woking Conference on Programming Concepts and Methods.

[64]

Philip Wadler. 2012. Propositions as Sessions. In 17th ACM SIGPLAN International Conference on Functional Programming (ICFP). ACM, 273–286.

Digital Library

[65]

David Walker and Kevin Watkins. 2001. On Regions and Linear Types. In 6th ACM SIGPLAN International Conference on Functional Programming (ICFP’06). ACM, 181–192.

[66]

Kevin Watkins, Iliano Cervesato, Frank Pfenning, and David Walker. 2002. A Concurrent Logical Framework I: Judgments and Properties. Technical Report CMU-CS-02-101. Computer Science Department, Carnegie Mellon University. Revised May 2003.

[67]

Max Willsey, Rokhini Prabhu, and Frank Pfenning. 2016. Design and Implementation of Concurrent C0. In Fourth International Workshop on Linearity.

Cited By

Kavanagh RPientka B(2024)Message-Observing SessionsProceedings of the ACM on Programming Languages10.1145/36498598:OOPSLA1(1351-1379)Online publication date: 29-Apr-2024
https://dl.acm.org/doi/10.1145/3649859
Moine AWestrick SBalzer S(2024)DisLog: A Separation Logic for DisentanglementProceedings of the ACM on Programming Languages10.1145/36328538:POPL(302-331)Online publication date: 5-Jan-2024
https://dl.acm.org/doi/10.1145/3632853
Marshall DOrchard D(2024)Non-linear communication via graded modal session typesInformation and Computation10.1016/j.ic.2024.105234301(105234)Online publication date: Dec-2024
https://doi.org/10.1016/j.ic.2024.105234
Show More Cited By

Index Terms

Manifest sharing with session types
1. Software and its engineering
  1. Software notations and tools
    1. General programming languages
      1. Language types
        Concurrent programming languages
2. Theory of computation
  1. Logic

Recommendations

Haskell session types with (almost) no class
HASKELL '08

We describe an implementation of session types in Haskell. Session types statically enforce that client-server communication proceeds according to protocols. They have been added to several concurrent calculi, but few implementations of session types ...
Gradual session types

Session types are a rich type discipline, based on linear types, that lift the sort of safety claims that come with type systems to communications. However, web-based applications and micro services are often written in a mix of languages, with type ...
Session types revisited

Session types are a formalism used to model structured communication-based programming. A binary session type describes communication by specifying the type and direction of data exchanged between two parties. When session types and session processes ...

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages

Proceedings of the ACM on Programming Languages Volume 1, Issue ICFP

September 2017

1173 pages

EISSN:2475-1421

DOI:10.1145/3136534

Issue’s Table of Contents

Copyright © 2017 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 29 August 2017

Published in PACMPL Volume 1, Issue ICFP

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Funding Sources

National Science Foundation
Mozilla Research

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

47
Total Citations
View Citations
803
Total Downloads

Downloads (Last 12 months)92
Downloads (Last 6 weeks)17

Reflects downloads up to 16 Jan 2025

Other Metrics

View Author Metrics

Citations

Cited By

Kavanagh RPientka B(2024)Message-Observing SessionsProceedings of the ACM on Programming Languages10.1145/36498598:OOPSLA1(1351-1379)Online publication date: 29-Apr-2024
https://dl.acm.org/doi/10.1145/3649859
Moine AWestrick SBalzer S(2024)DisLog: A Separation Logic for DisentanglementProceedings of the ACM on Programming Languages10.1145/36328538:POPL(302-331)Online publication date: 5-Jan-2024
https://dl.acm.org/doi/10.1145/3632853
Marshall DOrchard D(2024)Non-linear communication via graded modal session typesInformation and Computation10.1016/j.ic.2024.105234301(105234)Online publication date: Dec-2024
https://doi.org/10.1016/j.ic.2024.105234
Francalanza ATabone GPfenning F(2024)Implementing a Message-Passing Interpretation of the Semi-Axiomatic Sequent Calculus (Sax)Coordination Models and Languages10.1007/978-3-031-62697-5_16(295-313)Online publication date: 11-Jun-2024
https://doi.org/10.1007/978-3-031-62697-5_16
Caires LToninho B(2024)The Session Abstract MachineProgramming Languages and Systems10.1007/978-3-031-57262-3_9(206-235)Online publication date: 5-Apr-2024
https://doi.org/10.1007/978-3-031-57262-3_9
Smeele TJongmans S(2023)Choreographic Programming of Isolated TransactionsElectronic Proceedings in Theoretical Computer Science10.4204/EPTCS.378.5378(49-60)Online publication date: 13-Apr-2023
https://doi.org/10.4204/EPTCS.378.5
Iraci GChuang CHu RZiarek L(2023)Validating IoT Devices with Rate-Based Session TypesProceedings of the ACM on Programming Languages10.1145/36228547:OOPSLA2(1589-1617)Online publication date: 16-Oct-2023
https://dl.acm.org/doi/10.1145/3622854
Saffrich HThiemann P(2023)Polymorphic Typestate for Session TypesProceedings of the 25th International Symposium on Principles and Practice of Declarative Programming10.1145/3610612.3610624(1-15)Online publication date: 22-Oct-2023
https://dl.acm.org/doi/10.1145/3610612.3610624
Das AWang DHoffmann J(2023)Probabilistic Resource-Aware Session TypesProceedings of the ACM on Programming Languages10.1145/35712597:POPL(1925-1956)Online publication date: 11-Jan-2023
https://dl.acm.org/doi/10.1145/3571259
Jacobs JBalzer S(2023)Higher-Order Leak and Deadlock Free LocksProceedings of the ACM on Programming Languages10.1145/35712297:POPL(1027-1057)Online publication date: 11-Jan-2023
https://dl.acm.org/doi/10.1145/3571229
Show More Cited By

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

Media

Figures

Other

Tables

View Issue’s Table of Contents