LaCasa: lightweight affinity and object capabilities in Scala

HallerPhilipp,; LoikoAlex,

doi:10.1145/3022671.2984042

Cited by 8 publications

(7 citation statements)

References 58 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The underlying problem that our effect system solves is a general one: we need to restrict the lifetime of a resource (capabilities in our case) to a certain dynamic region (the call to handle in our case). This problem occurs in the domain of regionbased resource management (Kiselyov & Shan, 2008), object capabilities (Haller & Loiko, 2016), delimited control (Dybvig et al, 2007), scope safety in type-safe metaprogramming (Parreaux et al, 2017), as well as with prompt-based implementations of effect handlers (Brachthäuser & Schuster, 2017). Our effect system is inspired by the λ calculus (Zhang & Myers, 2019), which uses dependent types to track the set of used labels (i.e., capabilities) in the effect type.…”

Section: Establishing Effect Safetymentioning

confidence: 99%

Effekt: Capability-passing style for type- and effect-safe, extensible effect handlers in Scala

Brachthäuser¹,

Schuster²,

Ostermann³

2020

J. Funct. Prog.

View full text Add to dashboard Cite

Effect handlers are a promising way to structure effectful programs in a modular way. We present the Scala library Effekt, which is centered around capability passing and implemented in terms of a monad for multi-prompt delimited continuations. Effekt is the first library implementation of effect handlers that supports effect safety and effect polymorphism without resorting to type-level programming. We describe a novel way of achieving effect safety using intersection types and path-dependent types. The effect system of our library design fits well into the programming paradigm of capability passing and is inspired by the effect system of Zhang & Myers (2019, Proc. ACM Program. Lang.3(POPL), 5:1-5:29). Capabilities carry an abstract type member, which represents an individual effect type and reflects the use of the capability on the type level. We represent effect rows as the contravariant intersection of effect types. Handlers introduce capabilities and remove components of the intersection type. Reusing the existing type system of Scala, we get effect subtyping and effect polymorphism for free.

show abstract

Section: Establishing Effect Safetymentioning

confidence: 99%

Effekt: Capability-passing style for type- and effect-safe, extensible effect handlers in Scala

Brachthäuser¹,

Schuster²,

Ostermann³

2020

J. Funct. Prog.

View full text Add to dashboard Cite

show abstract

“…Consequently, it cannot utilize unions, even though they naturally express the underlying communication. 9 Others have considered static assurance of actor isolation through types (Srinivasan & Mycroft, 2008;Clebsch et al, 2015;Haller & Loiko, 2016) or verification (Summers & Müller, 2016). These approaches focus on isolating mutable heap references among actors, versus partial failure of components discussed here.…”

Section: Related Workmentioning

confidence: 99%

Typed dataspace actors

2020

View full text Add to dashboard Cite

Absatract Actors collaborate via message exchanges to reach a common goal. Experience has shown, however, that pure message-based communication is limiting and forces developers to use design patterns. The recently introduced dataspace actor model borrows ideas from the tuple space realm. It offers a tightly controlled, shared storage facility for groups of actors. In this model, actors assert facts that they wish to share and interests in such assertions. The dataspace notifies interested parties of changes to the set of assertions that they are interested in. Although it is straightforward to add the dataspace model to untyped languages, adding a typed interface is both necessary and challenging. Without restrictions on exchanged data, a faulty actor may propagate erroneous data through a malformed assertion, causing an otherwise well-behaved actor to crash—violating the key principle of failure isolation. A properly designed type system can prevent this scenario and rule out other kinds of uncooperative actors. This paper presents the first structural type system for the dataspace model of actors; it does not address the question of behavioral types for assertion-oriented protocols.

show abstract

“…It is important to note that this strategy requires notifying a silo's host whenever a SiloRef to the silo reaches a new machine, to increase the silo's reference count. The second approach leverages uniqueness types in Scala (Haller & Odersky, 2010;Haller & Loiko, 2016). Here, SiloRefs are locally unique, and the programmer can explicitly declare a SiloRef as unused; the type system ensures that such an "unused" SiloRef is not used again subsequently.…”

Section: Memory Reclamationmentioning

confidence: 99%

A programming model and foundation for lineage-based distributed computation

Haller¹,

Miller

Müller³

2018

J. Funct. Prog.

Self Cite

View full text Add to dashboard Cite

The most successful systems for “big data” processing have all adopted functional APIs. We present a new programming model, we call function passing, designed to provide a more principled substrate, or middleware, upon which to build data-centric distributed systems like Spark. A key idea is to build up a persistent functional data structure representing transformations on distributed immutable data by passing well-typed serializable functions over the wire and applying them to this distributed data. Thus, the function passing model can be thought of as a persistent functional data structure that is distributed, where transformations performed on distributed data are stored in its nodes rather than the distributed data itself. One advantage of this model is that failure recovery is simplified by design – data can be recovered by replaying function applications atop immutable data loaded from stable storage. Deferred evaluation is also central to our model; by incorporating deferred evaluation into our design only at the point of initiating network communication, the function passing model remains easy to reason about while remaining efficient in time and memory. Moreover, we provide a complete formalization of the programming model in order to study the foundations of lineage-based distributed computation. In particular, we develop a theory of safe, mobile lineages based on a subject reduction theorem for a typed core language. Furthermore, we formalize a progress theorem that guarantees the finite materialization of remote, lineage-based data. Thus, the formal model may serve as a basis for further developments of the theory of data-centric distributed programming, including aspects such as fault tolerance. We provide an open-source implementation of our model in and for the Scala programming language, along with a case study of several example frameworks and end-user programs written atop this model.

show abstract

LaCasa: lightweight affinity and object capabilities in Scala

Cited by 8 publications

References 58 publications

Effekt: Capability-passing style for type- and effect-safe, extensible effect handlers in Scala

Effekt: Capability-passing style for type- and effect-safe, extensible effect handlers in Scala

Typed dataspace actors

A programming model and foundation for lineage-based distributed computation

Contact Info

Product

Resources

About