Results 1  10
of
11
Scalable Component Abstractions
, 2005
"... 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 th ..."
Abstract

Cited by 103 (13 self)
 Add to MetaCart
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 frontend.
Independently extensible solutions to the expression problem
 In Proc. FOOL 12
, 2005
"... The expression problem is fundamental for the development of extensible software. Many (partial) solutions to this problem have been proposed in the past, but the question of how to use different, independent extensions jointly has received less attention so far. This paper proposes solutions to the ..."
Abstract

Cited by 55 (6 self)
 Add to MetaCart
(Show Context)
The expression problem is fundamental for the development of extensible software. Many (partial) solutions to this problem have been proposed in the past, but the question of how to use different, independent extensions jointly has received less attention so far. This paper proposes solutions to the expression problem that make it possible to combine independent extensions in a flexible, modular, and typesafe way. The solutions, formulated in the programming language Scala, are affected with only a small implementation overhead and are relatively easy to implement by hand. 1. The Expression Problem Since software evolves over time, it is essential for software systems to be extensible. But the development of extensible software poses many design and implementation problems, especially, if extensions cannot be anticipated. The expression problem is probably the most fundamental one among these problems. It arises when recursively defined datatypes and operations on these types have to be extended simultaneously. The term expression problem was originally coined by Phil Wadler in a post on the JavaGenericity mailing list [34], although it was Cook who first discussed this problem [9]. His work motivated several others to reason about variants of the problem in the following years [18, 27, 17, 12]. In his post to the JavaGenericity mailing list, Wadler also proposed a solution to the problem written in an extended version of GENERIC JAVA [3]. Only later it appeared that this solution could not be typed. For this paper, we paraphrase the problem in the following way: Suppose we have a datatype which is defined by a Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee.
Extensible Algebraic Datatypes with Defaults
, 2001
"... A major problem for writing extensible software arises when recursively defined datatypes and operations on these types have to be extended simultaneously without modifying existing code. This paper introduces Extensible Algebraic Datatypes with Defaults which promote a simple programming pattern to ..."
Abstract

Cited by 48 (9 self)
 Add to MetaCart
(Show Context)
A major problem for writing extensible software arises when recursively defined datatypes and operations on these types have to be extended simultaneously without modifying existing code. This paper introduces Extensible Algebraic Datatypes with Defaults which promote a simple programming pattern to solve this well known problem. We show that it is possible to encode extensible algebraic datatypes in an objectoriented language, using a new design pattern for extensible visitors. Extensible algebraic datatypes have been successfully applied in the implementation of an extensible Java compiler. Our technique allows for the reuse of existing components in compiler extensions without the need for any adaptations.
The Recursive Record Semantics of Objects Revisited
 Journal of Functional Programming
, 2001
"... In a callbyvalue language, representing objects as recursive records requires using an unsafe fixpoint. We design, for a core language including extensible records, a type system which rules out unsafe recursion and still supports the reconstruction of a principal type. We illustrate the expressiv ..."
Abstract

Cited by 37 (1 self)
 Add to MetaCart
(Show Context)
In a callbyvalue language, representing objects as recursive records requires using an unsafe fixpoint. We design, for a core language including extensible records, a type system which rules out unsafe recursion and still supports the reconstruction of a principal type. We illustrate the expressive power of this language with respect to objectoriented programming by introducing a sublanguage for "mixinbased" programming.
Evolving Software with Extensible Modules
, 2002
"... We present the programming language Keris, an extension of Java with explicit support for software evolution. Keris introduces extensible modules as the basic building blocks for software. Modules are composed hierarchically revealing explicitly the architecture of systems. A distinct feature of the ..."
Abstract

Cited by 24 (4 self)
 Add to MetaCart
We present the programming language Keris, an extension of Java with explicit support for software evolution. Keris introduces extensible modules as the basic building blocks for software. Modules are composed hierarchically revealing explicitly the architecture of systems. A distinct feature of the module design is that modules do not get linked manually. Instead, the wiring of modules gets infered. The module assembly and refinement mechanism of Keris is not restricted to the unanticipated extensibility of atomic modules. It also allows to extend fully linked systems by replacing selected submodules with compatible versions without needing to relink the full system. Extensibility is typesafe and noninvasive; i.e. the extension of a module preserves the original version and does not require access to source code.
Reachability Analysis of Term Rewriting Systems with Timbuk
 LPAR PROCEEDINGS
, 2001
"... We present Timbuk  a tree automata library  which implements usual operations on tree automata as well as a completion algorithm used to compute an overapproximation of the set of descendants (E) for a regular set E and a term rewriting system R, possibly non linear and non terminating. On seve ..."
Abstract

Cited by 14 (1 self)
 Add to MetaCart
We present Timbuk  a tree automata library  which implements usual operations on tree automata as well as a completion algorithm used to compute an overapproximation of the set of descendants (E) for a regular set E and a term rewriting system R, possibly non linear and non terminating. On several examples of term rewriting systems representing programs and systems to verify, we show how to use Timbuk to construct their approximations and then prove unreachability properties of these systems.
Simple type inference for structural polymorphism
 In: The Ninth International Workshop on Foundations of ObjectOriented Languages
, 2002
"... We propose a new way to mix constrained types and type inference, where the interaction between the two is minimal. By using local constraints embedded in types, rather than the other way round, we obtain a system which keeps the usual structure of an HindleyMilner type system. In practice, this me ..."
Abstract

Cited by 9 (4 self)
 Add to MetaCart
(Show Context)
We propose a new way to mix constrained types and type inference, where the interaction between the two is minimal. By using local constraints embedded in types, rather than the other way round, we obtain a system which keeps the usual structure of an HindleyMilner type system. In practice, this means that it is easy to introduce local constraints in existing type inference algorithms. Eventhough our system is notably weaker than general constraintbased type systems, making it unable to handle subtyping for instance, it is powerful enough to accomodate many features, from simple polymorphic records à la Ohori to Objective Caml’s polymorphic variants, and accurate typing of pattern matching (i.e. polymorphic message dispatch), all these through tiny variations in the constraint part of the system. 1.
Reachability Analysis over Term Rewriting Systems
, 2004
"... This paper surveys some techniques and tools for achieving reachability analysis over term rewriting systems. The core of those techniques is a generic tree automata completion algorithm used to compute in an exact or approximated way the set of descendants (or reachable terms). This algorithm has b ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
This paper surveys some techniques and tools for achieving reachability analysis over term rewriting systems. The core of those techniques is a generic tree automata completion algorithm used to compute in an exact or approximated way the set of descendants (or reachable terms). This algorithm has been implemented in the Timbuk tool. Furthermore, we show that many classes with regular sets of descendants of the literature corresponds to specific instances of the tree automata completion algorithm and can thus be e#ciently computed by Timbuk. An extension of the completion algorithm to conditional term rewriting systems and some applications are also presented.
A Graphical Development Environment for Functional Logic Languages
 Universidad Politécnica de Valencia
, 2000
"... In this paper we present an Integrated Development Environment based on the Programming Environment that support the Functional Logic languages selected: Curry and TOY. The environment has been built using the Tcl/Tk language. The main feature of this environment is its portability, as we show the e ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
In this paper we present an Integrated Development Environment based on the Programming Environment that support the Functional Logic languages selected: Curry and TOY. The environment has been built using the Tcl/Tk language. The main feature of this environment is its portability, as we show the environment can support, with little changes, different functional and/or logic languages. Another interesting feature is that it can be programmed in some of those languages (Curry, Haskell, Prolog,. . . ) in a pure declarative way using their graphic user interface libraries. Moreover, the design of the environment has been done taking special care of the reusability aspect, following modern componentbased programming approaches.