Scalable component abstractions

Abstract

We identify three programming language abstractions for the construction of reusable components: abstract type members, explicit selftypes, and modular mixin composition. Together, these abstractions enable us to transform an arbitrary assembly of static program parts with hard references between them into a system of reusable components. The transformation maintains the structure of the original system. We demonstrate this approach in two case studies, a subject/observer framework and a compiler front-end.

A Comparison of Cluster and Grid Configurations Executing Image Processing Tasks in a Local Network

“…The software used to distribute tasks to nodes was custom written for this application, using the Scala programming language [4]. Scala is a functional and object-oriented language that was designed to run in the Java Virtual Machine and interoperate with Java libraries and APIs.…”

An object-oriented approach to datatype-generic programming

“…Note that encoding this in Java or C# would require (exponential) global program rewriting [2,32] as they do not support type members [20] (let alone higher-kinded types). However, Scala's design decisions regarding type members make some parts of the encoding more verbose than the Haskell version.…”

Applications = Components + GLoo

“…However, while our understanding of this technology has grown significantly over the last decade resulting, for example, in the definition of industrial-strength component models like Java Enterprise Beans [19] and the .NET framework [23], most existing component frameworks offer only limited support for the definition of higher-level, scalable, and domain-specific compositional mechanisms that reflect the characteristics and constraints of the components being composed [1,27]. The mismatch between the mechanisms offered by present-day component-oriented techniques and the methodology they are supposed to support is due to an unsuitable use of general-purpose programming languages, which are not tailored to software composition [16,20,21]. Furthermore, Aßmann [5] argues that a comprehensive component-oriented software development approach not only needs to provide abstractions to represent different component models and composition techniques, but it must also provide a systematic method for constructing large software systems.…”

“…Furthermore, Aßmann [5] argues that a comprehensive component-oriented software development approach not only needs to provide abstractions to represent different component models and composition techniques, but it must also provide a systematic method for constructing large software systems. In particular, a specially-designed composition language is required [5,16,20,21] that (i) allows for an efficient integration of heterogeneous software artifacts, (ii) provides support for a problem-oriented software development approach, and (iii) enables software engineers to incrementally construct component-oriented domain abstractions on demand.…”