Concas / Damiani / Scotto Agile Processes in Software Engineering and Extreme Programming

8th International Conference, XP 2007, Como, Italy, June 18-22, 2007, Proceedings
2007
ISBN: 978-3-540-73101-6
Verlag: Springer Berlin Heidelberg
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Englisch, 292 Seiten

Reihe: Programming and Software Engineering

This book constitutes the refereed proceedings of the 8th International Conference on Agile Processes in Software Engineering and eXtreme Programming, XP 2007, held in Como, Italy in June 2007.

The 10 revised full papers and 16 revised short papers presented together with four poster papers, 18 experience papers, two research ideas and three panel summaries were carefully reviewed and selected from 45 submissions. The papers are organized in topical sections on managing agile processes, extending agile methodologies, teaching and introducing agile methodologies, methods and tools, empirical studies, and methodology issue.

Written for: Researchers and professionals

Keywords: XP, agile methodologies, agile processes, agile programming, collaborative software development, embedded software, extreme programming, pair programming, risk management, software development, software engineering, software management, software process management, software testing, specification-driven software development

Autoren/Hrsg.

Concas, Giulio

Damiani, Ernesto

Scotto, Marco

Succi, Giancarlo

Inhaltsverzeichnis

1;Preface;6
2;Organization;8
3;Table of Contents;12
4;Comparing Decision Making in Agile and Non-agile Software Organizations;17
5;Up-Front Interaction Design in Agile Development;25
6;British Telecom Experience Report: Agile Intervention – BT’s Joining the Dots Events for Organizational Change;33
7;Agile Software Development Meets Corporate Deployment Procedures: Stretching the Agile Envelope;40
8;Supporting Agile Reuse Through Extreme Harvesting;44
9;Using Horizontal Displays for Distributed and Collocated Agile Planning;54
10;Applying Agile to Large Projects: New Agile Software Development Practices for Large Projects;62
11;Job Satisfaction and Motivation in a Large Agile Team;70
12;Motivation and Cohesion in Agile Teams;78
13;How to Build Supportfor Distributed Pair Programming;86
14;A Metamodel for Modeling and Measuring Scrum Development Process;90
15;Tracking the Evolution of Object-Oriented Quality Metrics on Agile Projects;100
16;FitClipse: A Fit-Based Eclipse Plug-In for Executable Acceptance Test Driven Development;109
17;EZUNIT: A Framework for Associating Failed Unit Tests with Potential Programming Errors;117
18;Does XP Deliver Quality and Maintainable Code?;121
19;Inspecting Automated Test Code: A Preliminary Study;131
20;A Non-invasive Method for the Conformance Assessment of Pair Programming Practices Based on Hierarchical Hidden Markov Models;139
21;Predicting Software Defect Density:A Case Study on Automated Static Code Analysis;153
22;Empirical Evidence Principle and Joint Engagement Practice to Introduce XP;157
23;Power of Recognition: A Conceptual Framework for Agile Capstone Project in Academic Environment;161
24;Agile Commitments: Enhancing Business Risk Management in Agile Development Projects;165
25;Usability in Agile Software Development: Extending the Interaction Design Process with Personas Approach;169
26;Defining an Integrated Agile Governance for Large Agile Software Development Environments;173
27;Enhancing Creativity in Agile Software Teams;177
28;Investigating Adoption of Agile Software Development Methodologies in Organisations;179
29;Agile Software Assurance;181
30;User Stories and Acceptance Tests as Negotiation Tools in Offshore Software Development;183
31;A Case Study of the Implementation of Agile Methods in a Bioinformatics Project;185
32;Adapting Test-Driven Development for Innovative Software Development Project;187
33;Learning Agile Methods in Practice: Advanced Educational Aspects of the Varese XP-UG Experience;189
34;Overcoming Brooks' Law;191
35;Project Bid on Iteration Basis;195
36;Making the Whole Product Agile – A Product Owners Perspective;200
37;Financial Organization Transformation Strategy;204
38;An Agile Approach to Requirement Specification;209
39;The Application of User Stories for Strategic Planning;214
40;Introducing Agile Methods into a Project Organisation;219
41;Agile Development Meets Strategic Design in the Enterprise;224
42;An Agile Approach for Integration of an Open Source Health Information System;229
43;Agile Practices in a Large Organization: The Experience of Poste Italiane;235
44;Multi-tasking Agile Projects: The Focal Point;238
45;Extreme Programming Security Practices;242
46;Multi-tasking Agile Projects: The Pressure Tank;247
47;The Creation of a Distributed Agile Team;251
48;Distributed Scrum in Research Project Management;256
49;Multiple Perspectives on Executable Acceptance Test-Driven Development;261
50;Test Driving the Wrong Car;266
51;Epistemological Justification of Test Driven Development in Agile Processes;269
52;How Does Readiness for Agile Development Relate to Team Climate and Individual Personality Attributes?;273
53;Communication Flow in Open Source Projects: An Analysis of Developers' Mailing Lists;277
54;Community Reflections;282
55;To Certify or Not to Certify;284
56;Learning More About “Software Best Practices”;287
57;Author Index;291

Leseproben

Supporting Agile Reuse Through Extreme Harvesting (p. 28-29)

Oliver Hummel and Colin Atkinson
University of Mannheim, Chair of Software Technology 68159 Mannheim, Germany

Abstract. 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 development cycles of agile methods and to use test cases - the agile measure of semantic acceptability - to influence the component search process. In this paper we discuss the issues involved in doing this in association with Extreme Programming, the most widely known agile development method, and Extreme Harvesting, a prototype technique for the test-driven harvesting of components from the Web. When combined in the appropriate way we believe they provide a good foundation for the fledgling concept of agile reuse.

1 Introduction
Agile development and software reuse are both strategies for building software systems more cost effectively. Agile methods do this by shunning activities which do not directly create executable code and by minimizing the risk of user dissatisfaction by means of tight validation cycles. Software reuse does this by simply reducing the amount of new code that has to be written to create a new application. Since they work towards the same goal it is natural to assume that they can easily be used together in everyday development projects. However, this is not the case. To date agile development and systematic software reuse have rarely been attempted in the same project. Moreover, there is very little if any mention of software reuse in the agile development literature, and at the time of writing there is only one published reuse concept whose stated aim is to reinforce agile development. This is the so called "agile reuse" approach of McCarey et. al. [12].

The reason for this lack of integration is the perceived incompatibility of agile approaches and software reuse. Whereas the former explicitly eschews the creation of software documentation, the latter is generally perceived as requiring it. And while agile methods usually regard class operations (i.e. methods) as defining the granularity of development increments, reuse methods typically regard classes as the smallest unit of reuse in object-oriented programming. As a third difference, reuse approaches tend to be more successful the "more" explicit architectural knowledge is reused (as in product line engineering), whereas agile development methods employ as little explicit architecture as possible. At first sight, therefore, there appears to be several fundamentally irreconcilable differences between the two approaches.

McCarey et. al suggest a way of promoting reuse in agile development through socalled "software recommendation" technology. Their "agile reuse" tool, RASCAL [10] is an Eclipse plug-in which uses collaborative and content-based filtering techniques [9] to proactively suggest method invocations to developers. It does this by attempting to cluster Java objects according to the methods they use, just as Amazon, for example, clusters its customers according to the books they buy. The tool monitors method invocations in the class currently under development to predict method calls that are likely to be soon needed and suggests them to the developer. To evaluate their system the authors experimentally predicted invocations of the Java Swing Library in common open source systems and claim precision rates of around 30%.

Although the concept of RASCAL fits well into the agile spirit of providing maximum support for "productive" activities, there is nothing in the technology which ties it specifically to agile development. The approach embodied in RASCAL can just as easily be used with any other development methodology that produces code, including traditional heavyweight processes. Moreover, the approach has the same fundamental weakness as other repository-based approaches – the quality of the recommendations is only as good as the quality of the code repository that is used to search for components. Unfortunately, to date there have been few if any successful attempts to set up and maintain viable component repositories [6]. The version of the tool described in [10] is clearly a prototype, but McCarey et el. do not present a strategy for solving this important problem. Moreover, although RASCAL showed impressive performance for the limited domain of Swing invocations, it is not clear whether this technique will work for other domains with many more classes that have much lower usage frequencies.

1.2 The Core Challenge

The core challenge of agile reuse lies in developing a reuse strategy that complements the principles of agile development and offers a way of promoting reuse in tandem with the key artifacts and practices of agile methods. Whilst proactive recommendation technology such as RASCAL is certainly valuable in complementing such a strategy it does not itself solve the issues mentioned above. In this paper we present an approach which we believe does address these challenges and thus represents a viable basis for the concept of agile reuse. The key idea is to use unit test cases, which in most agile methods should be defined before implementations, to influence the component searching process. Such test-driven development is one of the most fundamental principles of Extreme Programming, the most widely used agile method. Tests are used as the basic measure of a unit’s semantic acceptability. Once a code unit passes the tests defining its required behaviour it is regarded as "satisfactory" for the job in hand.