E-Book, Englisch, Band 4536, 292 Seiten, eBook
8th International Conference, XP 2007, Como, Italy, June 18-22, 2007, Proceedings
E-Book, Englisch, Band 4536, 292 Seiten, eBook
Reihe: Lecture Notes in Computer Science
ISBN: 978-3-540-73101-6
Verlag: Springer
Format: PDF
Kopierschutz: 1 - PDF Watermark
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
Zielgruppe
Research
Autoren/Hrsg.
Weitere Infos & Material
Managing Agile Processes.- Comparing Decision Making in Agile and Non-agile Software Organizations.- Up-Front Interaction Design in Agile Development.- British Telecom Experience Report: Agile Intervention – BT’s Joining the Dots Events for Organizational Change.- Agile Software Development Meets Corporate Deployment Procedures: Stretching the Agile Envelope.- Extending Agile Methodologies.- Supporting Agile Reuse Through Extreme Harvesting.- Using Horizontal Displays for Distributed and Collocated Agile Planning.- Applying Agile to Large Projects: New Agile Software Development Practices for Large Projects.- Teaching and Introducing Agile Methodologies.- Job Satisfaction and Motivation in a Large Agile Team.- Motivation and Cohesion in Agile Teams.- How to Build Support for Distributed Pair Programming.- Methods and Tools.- A Metamodel for Modeling and Measuring Scrum Development Process.- Tracking the Evolution of Object-Oriented Quality Metrics on Agile Projects.- FitClipse: A Fit-Based Eclipse Plug-In for Executable Acceptance Test Driven Development.- EzUnit: A Framework for Associating Failed Unit Tests with Potential Programming Errors.- Empirical Studies.- Does XP Deliver Quality and Maintainable Code?.- Inspecting Automated Test Code: A Preliminary Study.- A Non-invasive Method for the Conformance Assessment of Pair Programming Practices Based on Hierarchical Hidden Markov Models.- Predicting Software Defect Density: A Case Study on Automated Static Code Analysis.- Empirical Evidence Principle and Joint Engagement Practice to Introduce XP.- Methodology Issue.- Power of Recognition: A Conceptual Framework for Agile Capstone Project in Academic Environment.- Agile Commitments: Enhancing Business Risk Management in Agile Development Projects.- Usability inAgile Software Development: Extending the Interaction Design Process with Personas Approach.- Defining an Integrated Agile Governance for Large Agile Software Development Environments.- Ph.D. Symposium.- Enhancing Creativity in Agile Software Teams.- Investigating Adoption of Agile Software Development Methodologies in Organisations.- Agile Software Assurance.- Posters.- User Stories and Acceptance Tests as Negotiation Tools in Offshore Software Development.- A Case Study of the Implementation of Agile Methods in a Bioinformatics Project.- Adapting Test-Driven Development for Innovative Software Development Project.- Learning Agile Methods in Practice: Advanced Educational Aspects of the Varese XP-UG Experience.- Experience Reports.- Overcoming Brooks’ Law.- Project Bid on Iteration Basis.- Making the Whole Product Agile – A Product Owners Perspective.- Financial Organization Transformation Strategy.- An Agile Approach to Requirement Specification.- The Application of User Stories for Strategic Planning.- Introducing Agile Methods into a Project Organisation.- Agile Development Meets Strategic Design in the Enterprise.- An Agile Approach for Integration of an Open Source Health Information System.- Agile Practices in a Large Organization: The Experience of Poste Italiane.- Multi-tasking Agile Projects: The Focal Point.- Extreme Programming Security Practices.- Multi-tasking Agile Projects: The Pressure Tank.- The Creation of a Distributed Agile Team.- Distributed Scrum in Research Project Management.- Multiple Perspectives on Executable Acceptance Test-Driven Development.- Test Driving the Wrong Car.- Epistemological Justification of Test Driven Development in Agile Processes.- Research Ideas.- How Does Readiness for Agile Development Relate to Team Climate andIndividual Personality Attributes?.- Communication Flow in Open Source Projects: An Analysis of Developers’ Mailing Lists.- Panels.- Community Reflections.- To Certify or Not to Certify.- Learning More About “Software Best Practices”.
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.
