Supporting Agile Reuse Through Extreme Harvesting

  title={Supporting Agile Reuse Through Extreme Harvesting},
  author={Oliver Hummel and Colin Atkinson},
Agile development and software reuse are both recognized as effective ways of improving time to market and quality in software engineering. However, they have traditionally been viewed as mutually exclusive technologies which are difficult if not impossible to use together. In this paper we show that, far from being incompatible, agile development and software reuse can be made to work together and, in fact, complement each other. The key is to tightly integrate reuse into the test-driven… 
Task Factoring to support reuse in Agile Methods
A new type of reuse asset is identified and a task factoring technique is proposed by taking advantage of iteration characteristics to support reuse in agile software development methods and can be applied and shown prototyping of task reuse in a video rental application.
Agile Product Backlog Reuse : Backlog Factoring Approach
This paper identifies catalytic activities and characteristics that promote reuse in a generalized agile process, and suggests a reuse technique for a product backlog item reuse in agile methods.
Searching for common ground: existing literature on automotive agile software product lines
The study shows that agile and product line development approaches tailored for the automotive domain are not yet fully explored in the literature, and most of the examined combinations are customizations of generic approaches or approaches stemming from other domains.
Component Recycling for Agile Methods
  • George Kakarontzas, I. Stamelos
  • Computer Science
    2010 Seventh International Conference on the Quality of Information and Communications Technology
  • 2010
This work shows how inherent characteristics of agile methods, particularly the provision of useful and complete partial components during the lifecycle, can be used constructively for the development of components.
An agile process supporting software reuse: an industrial experience
An industrial experience of integrating software reuse into an agile development process is presented and the proposed approach promotes a systematic reuse of software components based on both ontology-based software classification and Information Retrieval techniques.
Making the leap to a software platform strategy: Issues and challenges
Product Line Variability with Elastic Components and Test-Driven Development
The relationship between the popular agile practice of test-driven development (TDD) and how it can be used to assist the evolution of software components of a software product line is discussed.
Reusing functional software requirements in small-sized software enterprises: a model oriented to the catalog of requirements
The aim of this paper was to introduce the requirements reuse model for software requirements catalog (RRMSRC), and a set of guidelines to perform the main activities defined for reusing functional requirements within small-sized software enterprises is provided.
Code Conjurer: Pulling Reusable Software out of Thin Air
This paper discusses how component-based reuse of the form Douglas Mcllroy envisaged in the 1960s is still the exception rather than the rule, and most of the systematic software reuse practiced today uses heavyweight approaches such as product-line engineering or domain-specific frameworks.
A Semi-automated Process for Open Source Code Reuse
This work is proposing a semi-automated reuse process model for discovering open source code online, based on the requirements of the system under design, which illustrates the greedy approach of a reuse engineer, who wishes to reuse as much code as he can and implement the least possible.


An Eclipse Plugin to Support Agile Reuse
The benefits and the challenges encountered when implementing an Agile Reuse tool are presented, paying particular to attention to the XP methodology, and RASCAL is a recommender agent that infers the need for a reusable component and proactively recommends that component to the developer using a technique consistent with Agile principles.
Agile modeling: effective practices for extreme programming and the unified process
In this innovative book, Scott Ambler reviews how to: 1. Model on an XP project without detracting from its fast-moving and agile software development approach. 2. Simplify the modeling
Extreme programming explained - embrace change
You may love XP, or you may hate it, but Extreme Programming Explained will force you to take a fresh look at how you develop software.
Rascal: A Recommender Agent for Agile Reuse
The RASCAL recommender agent tracks usage histories of a group of developers to recommend to an individual developer components that are expected to be needed by that developer, and may recommend items that the developer has actually employed previously.
Using the Web as a Reuse Repository
This paper surveys reuse repositories on the Web and estimates the amount of software currently available in them and briefly discusses how this software can be harvested by means of general purpose web search engines.
A survey of software reuse libraries
A survey of methods of storage and retrieval of software assets in software libraries finds that most existing solutions are either too ineffective to be useful or too intractable to be usable.
Design patterns: elements of reuseable object-oriented software
The book is an introduction to the idea of design patterns in software engineering, and a catalog of twenty-three common patterns. The nice thing is, most experienced OOP designers will find out
Refactoring - Improving the Design of Existing Code
  • M. Fowler
  • Computer Science
    Addison Wesley object technology series
  • 1999
Almost every expert in Object-Oriented Development stresses the importance of iterative development. As you proceed with the iterative development, you need to add function to the existing code base.
Test-driven Development - by example
  • Kent L. Beck
  • Computer Science
    The Addison-Wesley signature series
  • 2003
Drive development with automated tests, a style of development called “Test-Driven Development” (TDD for short), which aims to dramatically reduce the defect density of code and make the subject of work crystal clear to all involved.
Software reuse research: status and future
This paper briefly summarizes software reuse research, discusses major research contributions and unsolved problems, provides pointers to key publications, and introduces four papers selected from