Comparing frameworks and layered refinement

Abstract

Object-oriented frameworks are a popular mechanism for building and evolving large applications and software product lines. This paper describes an alternative approach to software construction, Java Layers (JL), and evaluates JL and frameworks in terms of flexibility, ease of use, and support for evolution. Our experiment compares Schmidt's ACE framework against a set of ACE design patterns that have been implemented in JL. We show how problems of framework evolution and overfeaturing can be avoided using JL's component model, and we demonstrate that JL scales better than frameworks as the number of possible application features increases. Finally, we describe how constrained parametric polymorphism and a small number of language features can support JL's model of loosely coupled components and stepwise program refinement. KeywordsFrameworks, parametric polymorphism, mixins, layers. INTRODUCTIONSurveys show that nearly three quarters of all large software projects are cancelled, over budget, or late [20]. To address this problem, various methods of reusing code and reducing design complexity have been proposed. In terms of reusing both code and design to build large applications, object-oriented frameworks [2,17,27] represent the current state of the art when using general-purpose programming languages. Frameworks are starter kits that use abstract classes to provide partially implemented applications. Different applications can be created from a single framework by providing different implementations of these abstract classes, so frameworks are ideal for supporting software product lines, which are families of related software products.

Composing high-performance memory allocators

“…Some of the software engineering advantages of using mixins to build software layers (e.g., heap layers) have been discussed previously, especially focusing on ease of refinement [5,9,21]. We found that using heap layers as a means of stepwise refinement greatly simplified allocator construction.…”

FeatureC++: On the Symbiosis of Feature-Oriented and Aspect-Oriented Programming

“…Eisenecker et al utilize static C++ metaprogramming [13]. Several approaches solve the extensibility problem, introduced by Findler et al [14]: Java Layers [8], Jak [5], Jiazzi [23]. Regarding the constructor problem and extensibility problem, FeatureC++ is inspired by these approaches.…”

“…One appropriate way to implement features of program families in a modular way are Mixin Layers [31]. Mixin Layers can be implemented using C++ templates [31], P++ [29], Jak [5], Java Layers [8], Jiazzi [23], and Delegation Layers [25]. All these approaches leave aside the problem of lacking crosscutting modularity.…”

“…The constructor problem in incremental designs was introduced by Smaragdakis et al [30]. Java Layers solve it by automatic constructor propagation from parent to child classes [8]. Eisenecker et al utilize static C++ metaprogramming [13].…”

Aspect-oriented programming with Jiazzi

“…Mixin layers [22] improve on this by using a layer of mixins to modularize a collaboration between many objects. Java Layers [4,3] adds mixin layers to the Java language. The sibling class pattern [3] enabled by Java Layers provides the same functionality as Jiazzi's open packages.…”