Agile Processes in Software Engineering and Extreme Programming (eBook)

8th International Conference, XP 2007, Como, Italy, June 18-22, 2007

Giulio Concas, Ernesto Damiani, Marco Scotto, Giancarlo Succi (Eds.) (Herausgeber)

eBook Download: PDF

2007 | 1. Auflage
292 Seiten
Springer-Verlag
978-3-540-73101-6 (ISBN)

Infos

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

Inhalt

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

Textauszug

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.

Produkt-Details

• Erscheint lt. Verlag: 1.1.2007
• Sprache: englisch
• Themenwelt: Informatik ► Software Entwicklung ► Agile Software Entwicklung
• ISBN-10: 3-540-73101-6 / 3540731016
• ISBN-13: 978-3-540-73101-6 / 9783540731016