Function passing: a model for typed, distributed functional programming

Miller, Heather; Haller, Philipp; Müller, Normen; Boullier, Jocelyn

doi:10.1145/2986012.2986014

Cited by 11 publications

(9 citation statements)

References 23 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Multitier Programming Multitier programming [13,14,43,45,46,47,53] is in the tradition of programming languages for distributed systems with influential languages such as Argus [28], Emerald [4], Distributed Oz [22,58] and Dist-Orc [2]. More recent contributions focus on specific design aspects, e.g., cloud types to ensure eventual consistency [7], conflict-free replicated data types (CRDT) [55], language support for safe distribution of computations [34] and fault tolerance [33].…”

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

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

show abstract

“…ctx |-{A: forall: "?e": event []-> "?e" =>> ("Fs'" $ "Fn", "Fors", "Fois") = request C $ "Fn" $ ("Fs" $ "Fn") $ "?e"} (c) High-level DSLs, language extensions and tools [Bakst et al 2017;Biely et al 2013;Burckhardt et al 2012;Cejtin et al 1995;Kato et al 1993;Ketsman et al 2019;Killian et al 2007;Liu et al 2012;Miller et al 2016;Salvaneschi et al 2019;Samanta et al 2013;Weisenburger et al 2018] have been used to raise the level of abstraction, and improve the reliability of distributed systems. Model checking has been extensively applied for bounded verification [Dutertre et al 2018;Jackson 2006;John et al 2013;Killian et al 2007;Konnov et al 2017;Marić et al 2017;Musuvathi and Engler 2004;Yabandeh et al 2009;Yang et al 2009;Zave 2012] of distributed algorithms.…”

Section: Related Workmentioning

confidence: 99%

TLC: temporal logic of distributed components

Griffin

Lesani

Shadab

et al. 2020

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Distributed systems are critical to reliable and scalable computing; however, they are complicated in nature and prone to bugs. To manage this complexity, network middleware has been traditionally built in layered stacks of components. We present a novel approach to compositional verification of distributed stacks to verify each component based on only the specification of lower components. We present TLC (Temporal Logic of Components), a novel temporal program logic that offers intuitive inference rules for verification of both safety and liveness properties of functional implementations of distributed components. To support compositional reasoning, we define a novel transformation on the assertion language that lowers the specification of a component to be used as a subcomponent. We prove the soundness of TLC and the lowering transformation with respect to a novel operational semantics for stacks of composed components in partially synchronous networks. We successfully apply TLC to compose and verify a stack of fundamental distributed components. CCS Concepts: • Theory of computation → Program analysis; • Software and its engineering → Distributed programming languages; Distributed systems organizing principles.

show abstract

“…CPL [Bračevac et al 2016] is a calculus to create and combine multiple services in a type safe manner. Function passing [Haller et al 2018;Miller et al 2016] defines derived values of immutable remote data in a type safe way. Concurrent Objects [Filipović et al 2010] provides objects with serializability and linearizability by guaranteeing that concurrent implementations behave observational equivalent to sequential implementations.…”

Section: Formal Models For Concurrent and Distributed Computationsmentioning

confidence: 99%

A fault-tolerant programming model for distributed interactive applications

Mogk

Drechsler

Salvaneschi

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Ubiquitous connectivity of web, mobile, and IoT computing platforms has fostered a variety of distributed applications with decentralized state. These applications execute across multiple devices with varying reliability and connectivity. Unfortunately, there is no declarative fault-tolerant programming model for distributed interactive applications with an inherently decentralized system model. We present a novel approach to automating fault tolerance using high-level programming abstractions tailored to the needs of distributed interactive applications. Specifically, we propose a calculus that enables formal reasoning about applications' dataflow within and across individual devices. Our calculus reinterprets the functional reactive programming model to seamlessly integrate its automated state change propagation with automated crash recovery of device-local dataflow and disconnection-tolerant distribution with guaranteed automated eventual consistency semantics based on conflict-free replicated datatypes. As a result, programmers are relieved of handling intricate details of distributing change propagation and coping with distribution failures in the presence of interactivity. We also provides proofs of our claims, an implementation of our calculus, and an empirical evaluation using a common interactive application. CCS Concepts: • Theory of computation → Distributed computing models; • Software and its engineering → Software fault tolerance; Data flow languages.

show abstract

Function passing: a model for typed, distributed functional programming

Cited by 11 publications

References 23 publications

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

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

TLC: temporal logic of distributed components

A fault-tolerant programming model for distributed interactive applications

Contact Info

Product

Resources

About