Traits at work: The design of a new trait-based stream library

Recent years saw the development of a composition mechanism called traits. Traits are pure units of behavior that can be composed to form classes or other traits. The trait composition mechanism is an alternative to multiple or mixin inheritance in which the composer has full control over the trait composition.To evaluate the expressiveness of traits, some hierarchies were refactored, showing code reuse. However, such large refactorings, while valuable, may not exhibit all possible composition problems, since the hierarchies were previously expressed using single inheritance and following certain patterns.This paper presents our work on designing and implementing a new trait-based stream library named Nile. It evaluates how far traits enable reuse, what problems can be encountered when building a library using traits from scratch and compares the traits solution to alternative composition mechanisms. Nile's core allows the definition of compact collection and file streaming libraries as well as the implementation of a backward-compatible new stream library. Nile method size shows a reduction of 40% compared to the Squeak equivalent. The possibility to reuse the same set of traits to implement two distinct libraries is a concrete illustration of trait reuse capability.     

Strategy-;driven reuse: Bringing reuse from the Engineering Department to the Executive Boardroom

Organizations have predominantly utilized reuse in Engineering Departments for the purposes of reducing the cost and improving the quality of the software they develop. While these strategies have been successful, we believe that the full potential of reuse can only be tapped when reuse is brought to the Executive Boardroom as well. We propose that organizations tap reuse not only for cutting costs, but also for strategic and wide-;ranging business initiatives such as entering new markets, increasing agility in response to a dynamic marketplace, and competitive positioning and advantage. In order to do so effectively, organizations must harness the potential of reuse by migrating reuse into the company's business and product-;line planning processes. We present a framework for analyzing and changing reuse business practices. Such practices include cost-;reduction reuse, when the organization utilizes reuse for cost savings purposes; reuse-;enabled business, when the organization uses reuse to create new business opportunities; and strategy-;driven reuse, when the organization incorporates reuse in the formulation of its business and product-;line strategy for the purposes of obtaining competitive positioning and advantage. To determine whether or not reuse is the proper software development strategy to pursue, we utilize concepts in competitive software engineering, an integrated approach to software development that is attuned to the competitive demands of the marketplace. First, a framework is established by identifying and analyzing the organization's goals, strengths, and limitations, its market and its competitive environment. Based on these analyses, possible business or product strategies are formulated and one or more are chosen that help achieve the organization's goals. Finally, a development strategy is chosen. Following this choice, each step of the decision cycle should be re-;evaluated to ensure that it is consistent with the chosen development strategy.     

The SDL pattern approach – a reuse-driven SDL design methodology

There are several SDL methodologies that offer full system life-cycle support. Only few of them consider software reuse, not to mention high-level reuse of architecture and design. However, software reuse is a proven software engineering paradigm leading to high quality and reduced development effort. Experience made it apparent that – beyond the more traditional reuse of code – especially high-level reuse of architecture and design (as in the case of design patterns or frameworks) has the potential of achieving more systematic and widespread reuse. This paper presents the SDL pattern approach, a design methodology for distributed systems which integrates SDL-based system development with the pattern paradigm. It supports reuse of design knowledge modeled as SDL patterns and concentrates on the design phase of SDL-based system development. In order to get full life-cycle support, the pattern-based design process can be integrated within existing SDL methodologies.     

Teacher feedback to scaffold and refine demonstrated motion primitives on a mobile robot

Task demonstration is an effective technique for developing robot motion control policies. As tasks become more complex, however, demonstration can become more difficult. In this work, we introduce an algorithm that uses corrective human feedback to build a policy able to perform a novel task, by combining simpler policies learned from demonstration. While some demonstration-based learning approaches do adapt policies with execution experience, few provide corrections within low-level motion control domains or to enable the linking of multiple of demonstrated policies. Here we introduce Feedback for Policy Scaffolding (FPS) as an algorithm that first evaluates and corrects the execution of motion primitive policies learned from demonstration. The algorithm next corrects and enables the execution of a more complex task constructed from these primitives. Key advantages of building a policy from demonstrated primitives is the potential for primitive policy reuse within multiple complex policies and the faster development of these policies, in addition to the development of complex policies for which full demonstration is difficult. Policy reuse under our algorithm is assisted by human teacher feedback, which also contributes to the improvement of policy performance. Within a simulated robot motion control domain we validate that, using FPS, a policy for a novel task is successfully built from motion primitives learned from demonstration. We show feedback to both aid and enable policy development, improving policy performance in success, speed and efficiency.     

A software reuse measure: Monitoring an enterprise-level model driven development process

The purpose of the research discussed here is to establish a metric for the measurement of reuse in a generic enterprise-level model context and to use this approach to create a specific metric for a company. The paper demonstrates how a software development firm can monitor the reuse success in the development process using the measure. Traditionally, the reuse rate is defined as the percentage of the development effort retrieved as code segments from a software repository. The metric proposed here extends this definition to include reuse of generic enterprise-level model components. An example is given of the successful assessment of a reuse percentage for a software developer's actual project.     

The abstraction-first approach to data abstraction and algorithms

Experience in industry suggests that reuse does not happen without retraining. However, since reuse is meant to simplify programming, this paper argues the case for re-ordering a traditional data structures and algorithms course, using an object-oriented language, so that it starts from abstraction and reuse, and postpones coding from scratch as far as possible. The intention is that reuse should be learnt before other strategies, so coding from scratch does not have to be unlearnt before reuse seems natural. The paper presents experience with a restructured abstraction-first course, and proposes that an essential tool for such a strategy is a set of scaled-down libraries and frameworks, designed for teaching. Compared with a Modula-2-based course and an earlier C++-based course in which concepts were presented in a different order, more ground was covered, without a major change in the students’ results (grades).     

Superimposition: a component adaptation technique

Several authors have identified that the only feasible way to increase productivity in software construction is to reuse existing software. To achieve this, component-based software development is one of the more promising approaches. However, traditional research in component-oriented programming often assumes that components are reused “as-is”. Practitioners have found that “as-is” reuse seldom occurs and that reusable components generally need to be adapted to match the system requirements. Existing component object models provide only limited support for component adaptation, i.e. white-box techniques such as copy–paste and inheritance, and black-box approaches such as aggregation and wrapping. These techniques suffer from problems related to reusability, efficiency, implementation overhead or the self problem. To address these problems, this article proposes superimposition, a novel black-box adaptation technique that allows one to impose predefined, but configurable types of functionality on a reusable component. Three categories of typical adaptation types are discussed, related to the component interface, component composition and component monitoring. Superimposition and the types of component adaptation are exemplified by several examples.     

Reuse-Conducive Development Environments

Despite its well-recognized benefits, software reuse has not met its expected success due to technical, cognitive, and social difficulties. We have systematically analyzed the reuse problem (especially the cognitive and social difficulties faced by software developers who reuse) from a multidimensional perspective, drawing on our long-term research on information retrieval, human-computer interaction, and knowledge-based systems. Based on this analysis, we propose the concept of reuse-conducive development environments, which encourage and enable software developers to reuse through the smooth integration of reuse repository systems and development environments. We have designed, implemented, and evaluated CodeBroker—a reuse-conducive development environment—that autonomously locates and delivers task-relevant and personalized components into the current software development environment. Empirical evaluations of CodeBroker have shown that the system is effective in promoting reuse by enabling software developers to reuse components unknown to them, reducing the difficulties in locating components, and augmenting the programming capability of software developers.     

Incremental reasoning with lazy behavioral subtyping for multiple inheritance

Object-orientation supports code reuse and incremental programming. Multiple inheritance increases the possibilities for code reuse, but complicates the binding of method calls and thereby program analysis. Behavioral subtyping allows program analysis under an open world assumption; i.e., under the assumption that class hierarchies are extensible. However, method redefinition is severely restricted by behavioral subtyping, and multiple inheritance may lead to conflicting restrictions from independently designed superclasses. This paper presents a more liberal approach to incremental reasoning for multiple inheritance under an open world assumption. The approach, based on lazy behavioral subtyping, is well-suited for multiple inheritance, as it incrementally imposes context-dependent behavioral constraints on new subclasses. We first present the approach for a simple language and show how incremental reasoning can be combined with flexible code reuse. Then this language is extended with a hierarchy of interface types which is independent of the class hierarchy. In this setting, flexible code reuse can be combined with modular reasoning about external calls in the sense that each class is analyzed only once. We formalize the approach as a calculus and show soundness for both languages.     

A system dynamics approach for enhancing social behaviours regarding the reuse of packaging

There have been many attempts to reduce the amount of waste packaging through open dumping and burning, recycling, landfill, incineration, etc. However, there has been little attention paid to reuse as the simplest way to reduce waste. In order to motivate consumers to perform reuse behaviour, it is essential to understand how this behaviour can be influenced and what variables predict it. This paper aims to study the effectiveness of improving social aspects of reuse behaviour and investigate the variables that lead to increased reuse behaviour in a short time period. This paper selects a quantitative approach, the System Dynamics (SD) method, which offers a means by which to highlight the dynamics and interrelationships among the different social aspects in reuse behaviour. Different social aspects are extracted from Cognitive Behaviour Theory (CBT) as a basis with the Theory of Planning Behaviour (TOPB). The authors develop a Social Behaviour Aspect Model (SBAM) with three predictors: information values, awareness-changing variables and behavioural adaptation variables. The paper demonstrates its utility with a report on a recent empirical study that has used the model to provide important new findings about different social aspects to enhance reuse behaviour. These findings have clear implications for the packaging industry who intend to enhance reuse behaviour amongst consumers, encouraging them to take corrective and preventive actions at an early stage.     

A software framework for data analysis

The open-source Java software framework JStatCom is presented which supports the development of rich desktop clients for data analysis in a rather general way. The concept is to solve all recurring tasks with the help of reusable components and to enable rapid application development by adopting a standards based approach which is readily supported by existing programming tools. Furthermore, JStatCom allows to call external procedures from within Java that are written in other languages, for example Gauss, Ox or Matlab. This way it is possible to reuse an already existing code base for numerical routines written in domain-specific programming languages and to link them with the Java world. A reference application for JStatCom is the econometric software package JMulTi, which will shortly be introduced.     

Simulation model reuse: definitions, benefits and obstacles

The term ‘simulation model reuse’ can be taken to mean various things from the reuse of small portions of code, through component reuse, to the reuse of complete models. On a more abstract level, component design, model design and modelling knowledge are prime candidates for reuse. The reuse of simulation models is especially appealing, based on the intuitive argument that it should reduce the time and cost for model development. In a discussion with four simulation modelling experts, however, a number of issues were raised that mean these benefits may not be obtainable. These issues include the motivation to develop reusable models, the validity and credibility of models to be reused, and the cost and time for familiarisation. An alternative simulation methodology was proposed, that may lend itself better to model reuse.     

一种面向复用的增量软件开发过程框架

以复用思想指导软件开发是软件产业发展的趋势,而当前主要面向复用的软件开发方法没有考虑到我国软件企业以中小型为主的现状,缺乏针对性,使得复用在我国软件开发中应用不够广泛。在基于构件开发的基础上提出了一种面向复用的增量软件开发过程框架。该过程框架适于我国中小型软件企业,采用了以体系结构为指导的增量开发模式,涵盖了可复用资产的生产过程和利用可复用资产的软件开发过程。     

Constructing language processors with algebra combinators

Modular Monadic Semantics (MMS) is a well-known mechanism for structuring modular denotational semantic definitions for programming languages. The principal attraction of MMS is that families of language constructs can be independently specified and later combined in a mix-and-match fashion to create a complete language semantics. This has proved useful for constructing formal, yet executable, semantics when prototyping languages. In this work we demonstrate that MMS has an additional software engineering benefit. In addition to composing semantics for various language constructs, we can use MMS to compose various differing semantics for the same language constructs. This capability allows us to compose and reuse orthogonal language tasks such as type checking and compilation. We describe algebra combinators, the principal vehicle for achieving this reuse, along with a series of applications of the technique for common language processing tasks.     

Building with ParadisEO reusable parallel and distributed evolutionary algorithms

Numerous parallel and distributed evolutionary algorithms (PDEAs) and their implementations have been proposed and are available on the Web. A robust approach to make easier their code and design reuse is the framework approach. In this paper, we present some existing frameworks for PDEAs and their development requirements, and propose a new C++ open source framework, named Parallel and distributed Evolving Objects (ParadisEO). ParadisEO is basically devoted to the reusable and flexible design of parallel and distributed metaheuristics, but we focus here only on PDEAs. Compared to other related frameworks, ParadisEO allows more reuse flexibility, and provides more implemented parallel and distributed models. Furthermore, these models can be exploited by the user in a transparent way, and deployed as well on shared memory multi-processors as on distributed memory machines. The architecture has been experimented on two real-world applications: the radio network design and the spectroscopic data mining. The experimental results demonstrate the efficiency and robustness of the different models.     

A study of software reuse in NASA legacy systems

Software reuse is regarded as a highly important factor in reducing development overheads for new software projects; however, much of the literature is concerned with cost and labor savings that reuse brings to industrial software development and little is known about the inherent risks associated with reuse, particularly in the case of mission and safety-critical software systems. We present the preliminary findings of a research project geared toward assessing the impact of risk in National Aeronautics and Space Administration (NASA) legacy software in flight control systems. We introduce the concept of context variables and the impact they have on reuse within these legacy systems as well as the genealogy classification models, which provide a simple, concise method of mapping reuse between families of software projects. This research was conducted at Global Science and Technology, Inc. under NASA grant number NCC0NNG06GI57G.     

Opening up design science: The challenge of designing for reuse and joint development

The purpose of this paper is to advance design science by developing a framework for research on reuse and the relationship between external IT artifacts and their users. A design science approach to IS research needs to grapple with the fact that a number of relevant, economically attractive, external IT artifacts cannot be designed from scratch nor meaningfully evaluated based on the current state of development, and so design science research will struggle with incomplete cycles of design, relevance, and rigor. We suggest a strategic research agenda that integrates the design of the relationship between an external IT artifact and the user by considering the impact artifacts exert on users. Three dimensions derived from adaptive structuration theory inform our framework on three levels of design granularity (middle management, top management, and entrepreneur): agenda considers the dynamic properties of technological objects, adaptability refers to the functional affordance of external artifacts in development, and auspice captures the symbolic expression and scope for interpretation. We derive implications for research design.     

A component framework for reusing a proprietary computer-aided engineering environment

Nowadays, it is becoming more frequent for engineers to deal with problems and situations that require specific software and the commercially available applications may not result adequate. Because of this, the reuse of software components is becoming a normal practice for improving the productivity of the software programmers, and the quality of the products that they develop. The employment of reusable components presents a number of advantages, such as the reduction in time necessary to develop new software, or the simplification of many computational tasks.There are some proprietary software environments in the engineering domain that are practically de facto standards, since they offer a broad functionality, robustness and constant updating. Therefore, those environments could be ideal candidates to be reusable components when developing new software. An example of this is Matlab, which can be encapsulated, in order to use it as a true reusable component. This will provide the user with efficient tools for designing his/her own applications.Moreover, there is an increasing importance for any software to offer distributed services. To perform this task, it is fundamental to have at one’s disposal reusable components that support Internet-based distributed applications and services development.In the present work, a software component framework that effectively encapsulates Matlab is described. This software allows developers the reuse of Matlab, for both local and distributed applications. To address those issues the .NET technology was employed. The component framework developed can be integrated in the toolbars of software development environments supporting the .NET framework. This facilitates the construction of applications that can reuse the components, since the software developers can use and test them and change their properties in design-time.