Scalable component abstractions

Odersky, Martin; Zenger, Matthias

doi:10.1145/1094811.1094815

Cited by 149 publications

(69 citation statements)

References 46 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The programming language Scala proposes a new model for component systems [28]. Components in this model are classes, which can be combined using nesting and mixin composition.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

A Core Calculus for Scala Type Checking

Cremet

Garillot

Lenglet

et al. 2006

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

show abstract

“…The programming language Scala proposes a new model for component systems [28]. Components in this model are classes, which can be combined using nesting and mixin composition.…”

Section: Introductionmentioning

confidence: 99%

“…Furthermore, the identification of modules and objects provides new ways to formulate standard programming tasks such as the expression problem [14,33,27] and family polymorphism [12,28].…”

Section: Introductionmentioning

confidence: 99%

A Core Calculus for Scala Type Checking

Cremet

Garillot

Lenglet

et al. 2006

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

show abstract

“…The Cake pattern [34,54], in the Scala programming language, is an exception. This pattern uses virtual types, self types, path-dependent types and (static) mixin composition to model family polymorphism.…”

Section: Related Workmentioning

confidence: 99%

Feature-Oriented Programming with Object Algebras

Oliveira

Storm

Loh

et al. 2013

ECOOP 2013 – Object-Oriented Programming

View full text Add to dashboard Cite

Abstract. Object algebras are a new programming technique that enables a simple solution to basic extensibility and modularity issues in programming languages. While object algebras excel at defining modular features, the composition mechanisms for object algebras (and features) are still cumbersome and limited in expressiveness. In this paper we leverage two well-studied type system features, intersection types and type-constructor polymorphism, to provide object algebras with expressive and practical composition mechanisms. Intersection types are used for defining expressive run-time composition operators (combinators) that produce objects with multiple (feature) interfaces. Type-constructor polymorphism enables generic interfaces for the various object algebra combinators. Such generic interfaces can be used as a type-safe front end for a generic implementation of the combinators based on reflection. Additionally, we also provide a modular mechanism to allow different forms of self -references in the presence of delegation-based combinators. The result is an expressive, type-safe, dynamic, delegation-based composition technique for object algebras, implemented in Scala, which effectively enables a form of Feature-Oriented Programming using object algebras.

show abstract

“…Kompics is related to work in several areas: concurrent programming mod- Kompics's message-passing concurrency model is similar to the actor model [23], of which Erlang [12], the Unix lter and pipe model, Kilim [14] and Scala [13] are, perhaps, the best known examples. Similar to the actor model, message passing in Kompics involves bu ering events before they are handled in a rst-in rst-out (FIFO) order, thus, decoupling the thread that sends an event from the thread that handles an event.…”

Section: Related Workmentioning

confidence: 99%

Message-Passing Concurrency for Scalable, Stateful, Reconfigurable Middleware

Arad

Dowling

Haridi

2012

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Message-passing concurrency (MPC) is increasingly being used to build systems software that scales well on multi-core hardware. Functional programming implementations of MPC, such as Erlang, have also leveraged their stateless nature to build middleware that is not just scalable, but also dynamically reconfigurable. However, many middleware platforms lend themselves more naturally to a stateful programming model, supporting session and application state. A limitation of existing programming models and frameworks that support dynamic reconfiguration for stateful middleware, such as component frameworks, is that they are not designed for MPC. In this paper, we present Kompics, a component model and programming framework, that supports the construction and composition of dynamically reconfigurable middleware using stateful, concurrent, message-passing components. An added benefit of our approach is that by decoupling our component execution model, we can run the same code in both simulation and production environments. We present the architectural patterns and abstractions that Kompics facilitates and we evaluate them using a case study of a non-trivial key-value store that we built using Kompics. We show how our model enables the systematic development and testing of scalable, dynamically reconfigurable middleware.

QC 20130116

show abstract

Scalable component abstractions

Cited by 149 publications

References 46 publications

A Core Calculus for Scala Type Checking

A Core Calculus for Scala Type Checking

Feature-Oriented Programming with Object Algebras

Message-Passing Concurrency for Scalable, Stateful, Reconfigurable Middleware

Contact Info

Product

Resources

About