Improving design and implementation of OO container-like component libraries

Object-oriented design is usually driven by three main reusability principles: step-by-step design, design for reuse and design with reuse. However, these principles tend to be just partially applied to the subsequent object-oriented implementation, often because they conflict with other quality criteria (remarkably, efficiency). So, there is a gap between design and implementation: due to these conflicts developers use to give up design level abstractions during the implementation. In this paper we present a framework for bridging this gap for a concrete domain, the design and implementation of object-oriented container-like component libraries, such as JCF, STL, Booch Components, LEDA, etc. At the core of the framework we propose a new design pattern called emph{Shortcut} together with its corresponding implementation. The Shortcut pattern, introduced in a generic base class container, provides a secure and efficient access to items in a container decoupled from the implementation details of concrete containers. Shortcut enhances applying the same principles that drive the design process to the implementation process of these libraries: step-by-step implementation, implementation with reuse and implementation for reuse without penalising other quality criteria. Our framework not only supports the design and implementation of new libraries but also the reengineering of existing ones to overcome some of their drawbacks. We show by a case study, reengineering the Booch Components in Ada95, the application and benefits of our framework.Postprint (published version

Bridging the gap between design and implementation of components libraries

Object-oriented design is usually driven by three main reusability principles: step-by-step design, design for reuse and design with reuse. However, these principles are just partially applied to the subsequent object-oriented implementation, often due to efficienc y constraints, yielding to a gap between design and implementation. In this paper we provide a solution for bridging this gap for a concrete framework, the one of designing and implementing container-like component libraries, such as STL, Booc h Components, etc. Our approach is based on a new design pattern together with its corresponding implementation. The proposal enhances the same principles that drive the design process: step-by--step implementation (adding just what is needed in every step), implementation with reuse (component implementations are reused while library implementation progresses and component hierarchies grow) and implementation for reuse (intermediate component implementations can be reused in many different points o f the hierarchy). We use our approach in two different manners: for building a brand-new container-like component library, and for reengineering an existing one, Booch Components in Ada95.Postprint (published version

Adding efficient and reliable access paths to the JCF

The Java Collections Framework (JCF) is the standard Java library for representing and manipulating collections (i.e., objects that represent a group of objects, such as sets, lists, etc.). Although JCF provides adequate functionality for many purposes, it does not offer any mechanism for accessing directly the objects stored in collections apart from the standard Java references. This absence is a crucial functionality exhibited by many other widespread Java and non-Java collection libraries. In this paper, we carry out a reengineering process on the JCF to add this kind of alternative access paths, which we give the name of shortcuts. This process relies on a framework called Shortcut-Based Framework, which has been defined as library- independent. We present this framework and then we show how it may be tailored to the specific case of the JCF. The resulting JCF with shortcuts library is fully compatible with the original one (i.e., programs using the original JCF are not required to be modified), and exhibits good behaviour with respect to efficiency, reliability and internal quality. As an additional benefit of the framework, we mention that it can be applied to other collection libraries, as we have done before with an Ada95 one.Postprint (published version

Shortcuts: abstract "pointers''

In this work we present the specification and the implementation of a new abstract data type (ADT) called STORE. This new ADT allows the storage of a given collection of elements offering an abstract mechanism that supplies a direct access to them, alternative to the method defined by the standard operations of usual ADTs. The interest of the new mechanism stems from the efficiency of pointers, while avoiding the loss of modularity that usually occurs when pointers are used. The implementation of the operations offered by the new ADT is done by derivation from the equational specification. The representation chosen for the implementation of the new ADT makes the efficiency previously mentioned possible, even when the representation strategy requires the movement of the elements.Postprint (published version

The Alternative Migratory Pathways of the Drosophila Tracheal Cells Are Associated with Distinct Subsets of Mesodermal Cells

AbstractThe Drosophila tracheal system is a model for the study of the mechanisms that guide cell migration. The general conclusion from many studies is that migration of tracheal cells relies on directional cues provided by nearby cells. However, very little is known about which paths are followed by the migrating tracheal cells and what kind of interactions they establish to move in the appropriate direction. Here we analyze how tracheal cells migrate relative to their surroundings and which tissues participate in tracheal cell migration. We find that cells in different branches exploit different strategies for their migration; while some migrate through preexisting grooves, others make their way through homogeneous cell populations. We also find that alternative migratory pathways of tracheal cells are associated with distinct subsets of mesodermal cells and propose a model for the allocation of groups of tracheal cells to different branches. These results show how adjacent tissues influence morphogenesis of the tracheal system and offer a model for understanding how organ formation is determined by its genetic program and by the surrounding topological constraints

Reconciliando modularidad y eficiencia mediante atajos

Se presenta en este artículo una propuesta para el desarrollo de programas eficientes en el marco de la programación con tipos abstractos de datos (TAD), con el objetivo de respetar la estructura modular de los programas propia de este ámbito. La propuesta se centra en el concepto de atajo como camino eficiente de acceso a los datos, alternativo al acceso mediante las operaciones propias del TAD, y se desarrolla sobre un TAD concreto, el almacén de elementos. La definición de los atajos es altamente formal, mediante especificaciones algebraicas interpretadas con semántica inicial, de manera que el resultado tiene un significado bien definido y encaja sin problemas en el marco de la programación con TAD. La eficiencia se asegura mediante una implementación adecuada del tipo, que proporciona acceso constante a los datos siguiendo los atajos sin penalizar las otras operaciones del TAD. Se ilustra la utilidad de la propuesta mediante un ejemplo concreto.Peer ReviewedPostprint (author's final draft

How do software architects consider non-functional requirements: an exploratory study

© 2012 IEEE. Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, including reprinting/republishing this material for advertising or promotional purposes,creating new collective works, for resale or redistribution to servers or lists, or reuse of any copyrighted component of this work in other works.Dealing with non-functional requirements (NFRs) has posed a challenge onto software engineers for many years. Over the years, many methods and techniques have been proposed to improve their elicitation, documentation, and validation. Knowing more about the state of the practice on these topics may benefit both practitioners' and researchers' daily work. A few empirical studies have been conducted in the past, but none under the perspective of software architects, in spite of the great influence that NFRs have on daily architects' practices. This paper presents some of the findings of an empirical study based on 13 interviews with software architects. It addresses questions such as: who decides the NFRs, what types of NFRs matter to architects, how are NFRs documented, and how are NFRs validated. The results are contextualized with existing previous work.Peer ReviewedPostprint (author’s final draft

HiME: Hierarchical i* Modeling Editor

In this paper, we present HiME, a tool for editing i* models. Thedistinguishing characteristic of HiME is its ability to deal with inheritance. It includes specific operations for declaring an actor as heir of another and then stating the relationships between the intentional elements of both actors

Reengineering the booch component library

Component-based software development heavily relies on the ability of reusing components from a library with as little effort as possible. Among others, valuable features for reusing from a component library are: adaptability to many contexts, extensibility, abstraction and high level of robustness with respect to changes in some of their components. In this paper we study one of the most widely used component library for Ada 95, the Grady Booch’s one, mainly in relation to these features. Our study focuses on the Container-classes family, which present some drawbacks mainly due to the fact that some parent-classes depend on the concrete form of their children-classes. We propose a solution centred on changing the Containers base class. This new version of the Containers class offers a new concept, namely shortcut, that allows not only to avoid the dependencies between parent-classes and their children classes, but also offers some additional advantages, remarkably improving the efficiency of components.Peer ReviewedPostprint (author's final draft

A quality model for the Ada standard container library

The existence of a standard container library has been largely recognized as a key feature for improving the quality and effectiveness of Ada programming. In this paper, we aim at providing a quality model for making explicit the quality features (those concerning functionality, suitability, etc.) that determine the form that such a library might take. Quality features are arranged hierarchically according to the ISO/IEC quality standard. We tailor this standard to the specific context of container libraries, by identifying their observable attributes and establishing some tradeoffs among them. Afterwards, we apply the resulting model to a pair of existing container libraries. As main contribution of our proposal, we may say that the resulting quality model provides a structured framework for (1) discussing and evaluating the capabilities that the prospective Ada Standard Container Library might offer, and (2) analyzing the consequences of the decisions taken during its design.Peer ReviewedPostprint (author's final draft