Exceptional asynchronous session types: session types without tiers

Fowler, Simon; Lindley, Sam; Morris, John; Decova, Sára

doi:10.1145/3290341

Cited by 56 publications

(70 citation statements)

References 31 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Notes on Session Cancellation. There are a few literature on session cancellation, such as Fowler et al's EGV [7], which we do not follow for now. Instead, The session intervention pattern above uses branching (Select/Offer) to handle a cancellation.…”

Section: Figure 2: Completionmentioning

confidence: 91%

Fluent Session Programming in C#

Kimura

Imai

2020

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

We propose SessionC#, a lightweight session typed library for safe concurrent/distributed programming. The key features are (1) the improved fluent interface which enables writing communication in chained method calls, by exploiting C#'s out variables, and (2) amalgamation of session delegation with async/await, which materialises session cancellation in a limited form, which we call session intervention. We show the effectiveness of our proposal via a Bitcoin miner application. IntroductionSession types [8] are a theoretical framework for statically specifying and verifying communication protocols in concurrent and distributed programs. Session types guarantee that a well-typed program follows a safe communication protocol free from reception errors (unexpected messages) and deadlocks.The major gaps between session types and "mainstream" programming language type system are the absence of the two key features: (1) duality for checking the communication protocol realises reciprocal communication actions between two peers, and (2) linearity ensuring that each peer is exactly following the protocol, in the way that channel variables are exclusively used from one site for the exact number of times. Various challenges have been made for incorporating them into general-purpose languages including Java [12], Scala [28], Haskell [25,14,19,23], OCaml [24,13] and Rust [15,16].We observe that the above-mentioned gaps in session-based programming can be narrowed further by the recent advancement of programming languages, which is driven by various real-world programming issues. In particular, C# [1] is widely used in areas ranging from Windows and web application platforms to gaming (e.g. Unity), and known to be eagerly adopting various language features including async/await, reifiable generics, named parameters, out variables and extension methods.In this paper, we propose SessionC# -a library implementation of session types on top of the rich set of features in C#, and show its usefulness in concurrent/distributed programming, aiming for practicality. client server (int,int,int) «delegation» left right int choice (completed) (cancelled) cancel (asynchronously)Namely, (1) it has an improved fluent interface (i.e., method calls can be chained) via C#'s out variables, reducing the risk of linearity violation in an idiomatic way. Furthermore, (2) it enables session cancellation in a limited form -which we call session intervention -by utilising amalgamation of C#'s async/await and session delegation in thread-based concurrency. We illustrate the essential bits of SessionC# where a cancellable computation is guided by session types, by a use-case where a C# thread calculates a cancellable tak function which is designed to have a long running time [20]. The figure on the right depicts the overall communication protocol, which can be written in SessionC# as a protocol specification describing a client-server communication protocol from the client's viewpoint, as follows: var prot = Send(Val<(int,int,int)>, Deleg(chan:Recv(Unit,...

show abstract

Section: Figure 2: Completionmentioning

confidence: 91%

Fluent Session Programming in C#

Kimura

Imai

2020

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

show abstract

“…Hop [53] and Hop.js [54] are dynamically typed languages that follow a traditional client-server communication scheme with asynchronous callbacks. In Links [14,18] and Opa [46], functions are annotated to specify either client-or server-side execution. Both languages also follow the client-server 17:21 model and feature a static type system.…”

Section: Related Workmentioning

confidence: 99%

Implementing a Language for Distributed Systems: Choices and Experiences with Type Level and Macro Programming in Scala

Weisenburger

Salvaneschi

2020

Programming

View full text Add to dashboard Cite

Multitier programming languages reduce the complexity of developing distributed software by developing the distributed system within a single coherent code base. In multitier languages, the compiler or the runtime takes care of separating the code into the components of the distributed system. This approach enables abstraction over low level implementation details such as data representation, serialization and network protocols. The ScalaLoci programming language allows developers to declare the components of the system and their architectural relation at the type level, enabling static reasoning about distribution and remote communication and guaranteeing static type safety for data transfer across components. As the compiler automatically generates the communication boilerplate among components, data transfer among components can be modeled declaratively, by specifying the data flows in the reactive programming style.In this paper, we report on the ScalaLoci implementation and on our experience with embedding ScalaLoci's language features into Scala as a host language. We show how a combination of Scala's advanced type level programming and of Scala's macro system enable enriching the language with new abstractions for distributed systems. We describe the challenges we encountered for the implementation and report on the solutions we developed. Finally, we outline suggestions for improving the Scala macro system to better support embedding domain-specific abstractions. ACM CCS 2012The design of ScalaLoci unfolds around three major ideas. First, the distributed topology (i.e., separate locations that execute code) is explicit and specified by the programmer, who assigns code to each system component. Second, remote communication within the distributed system (i.e., with performance and failure characteristics different from local communication) is explicit and supports event-based interaction between components. Third, ScalaLoci abstractions are embedded as domain-specific features into an existing general purpose language. We lay out the design space for our language implementation and derive concrete design requirements.Explicit Specification of Distribution and Topology Some languages for distributed systems abstract over the topology, i.e., code is agnostic to the system's components and their connections. Such approach is often chosen for highly specialized programming models, e.g., streaming systems [16,62], intentionally hiding distribution. On the other end lie approaches where developers specify the topology. Distribution unavoidably becomes apparent when implementing different components, e.g., in actor systems [1]. While actor systems encapsulate components into actors, topological information is not encoded at the language level but managed explicitly by the developer.Clearly, a multitier programming model for developing generic distributed systems -similar to what the actor model offers -cannot abstract over distribution completely. To decide on the component that executes a specific part of the cod...

show abstract

“…Others have extended existing programming languages to embedded MPST directly within the language. For example, Links and SIL [16,26,4]. However, these approaches require extending the language and compiler.…”

Section: Related Workmentioning

confidence: 99%

Value-Dependent Session Design in a Dependently Typed Language

Muijnck-Hughes

Brady

Vanderbauwhede

2019

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

Session Types offer a typing discipline that allows protocol specifications to be used during typechecking, ensuring that implementations adhere to a given specification. When looking to realise global session types in a dependently typed language care must be taken that values introduced in the description are used by roles that know about the value.We present Sessions, a Resource Dependent Embedded Domain Specific Language (EDSL) for describing global session descriptions in the dependently typed language Idris. As we construct session descriptions the values parameterising the EDSLs' type keeps track of roles and messages they have encountered. We can use this knowledge to ensure that message values are only used by those who know the value. Sessions supports protocol descriptions that are computable, composable, higher-order, and value-dependent. We demonstrate Sessions expressiveness by describing the TCP Handshake, a multi-modal server providing echo and basic arithmetic operations, and a Higher-Order protocol that supports an authentication interaction step.

show abstract

Exceptional asynchronous session types: session types without tiers

Cited by 56 publications

References 31 publications

Fluent Session Programming in C#

Fluent Session Programming in C#

Implementing a Language for Distributed Systems: Choices and Experiences with Type Level and Macro Programming in Scala

Value-Dependent Session Design in a Dependently Typed Language

Contact Info

Product

Resources

About