Test-Driven Development

This chapter describes the practice of test-driven development (TDD) and its impact on the overall culture of quality in an organization based on the author’s experience introducing TDD into four existing development projects in an industrial setting. The basic concepts of TDD are explored from an industry practitioner’s perspective before elaborating on the benefits and challenges of adopting TDD within a development organization. The author observed that TDD was well-received by team members, and believes that other teams will have this same experience if they are prepared to evaluate their own experiences and address the challenges.

Agile Software Development Quality Assurance

Of great interest to software development professionals is whether the adaptive methods found in agile methodologies can be successfully implemented in a highly disciplined environment and still provide the benefits accorded to fully agile projects. As a general rule, agile software development methodologies have typically been applied to non-critical projects using relatively small project teams where there are vague requirements, a high degree of anticipated change, and no significant availability or performance requirements (Boehm & Turner, 2004). Using agile methods in their pure form for projects requiring either high availability, high performance, or both is considered too risky by many practitioners (Boehm et al., 2004; Paulk, 2001). When one investigates the various agile practices, however, one gets the impression that each may still have value when separated from the whole. This chapter discusses how one team was able to successfully drive software development quality improvements and reduce overall cycle time through the introduction of several individual agile development techniques. Through the use of a common-sense approach to software development, it is shown that the incorporation of individual agile techniques does not have to entail additional risk for projects having higher availability, performance, and quality requirements.

Software Configuration Management in Agile Development

Software configuration management (SCM) is an essential part of any software project and its importance is even greater on agile projects because of the frequency of changes. In this chapter, we argue that SCM needs to be done differently and cover more aspects on agile projects. We also explain how SCM processes and tools contribute both directly and indirectly to quality assurance. We give a brief introduction to central SCM principles and define a number of typical agile activities related to SCM. Subsequently, we show that there are general SCM guidelines for how to support and strengthen these typical agile activities. Furthermore, we establish a set of requirements that an agile method must satisfy to benefit the most from SCM. Following our general guidelines, an agile project can adapt the SCM processes and tools to its specific agile method and its particular context.

Agile Quality Assurance Techniques for GUI-Based Applications

This chapter motivates the need for new agile model-based testing mechanisms that can keep pace with agile software development/evolution. A new concentric loop-based technique, which effectively utilizes resources during iterative development, is presented. The tightest loop is called crash testing, which operates on each code check-in of the software. The second loop is called smoke testing, which operates on each day’s build. The third and outermost loop is called the “comprehensive testing” loop, which is executed after a major version of the software is available. Because rapid testing of software with a graphical-user interface (GUI) front-end is extremely complex, and GUI development lends itself well to agile processes, the GUI domain is used throughout the chapter as an example. The GUI model used to realize the concentric-loop technique is described in detail.

Handling of Software Quality Defects in Agile Software Development

Software quality assurance is concerned with the efficient and effective development of large, reliable, and high-quality software systems. In agile software development and maintenance, refactoring is an important phase for the continuous improvement of a software system by removing quality defects like code smells. As time is a crucial factor in agile development, not all quality defects can be removed in one refactoring phase (especially in one iteration). Documentation of quality defects that are found during automated or manual discovery activities (e.g., pair programming) is necessary to avoid wasting time by rediscovering them in later phases. Unfortunately, the documentation and handling of existing quality defects and refactoring activities is a common problem in software maintenance. To recall the rationales why changes were carried out, information has to be extracted from either proprietary documentations or software versioning systems. In this chapter, we describe a process for the recurring and sustainable discovery, handling, and treatment of quality defects in software systems. An annotation language is presented that is used to store information about quality defects found in source code and that represents the defect and treatment history of a part of a software system. The process and annotation language can not only be used to support quality defect discovery processes, but is also applicable in testing and inspection processes.

Quality Improvements from using Agile Development Methods

In the past few years, Siemens has gained considerable experience using agile processes with several projects of varying size, duration, and complexity. We have observed an emerging pattern of quality assurance goals and practices across these experiences. We will provide background information on the various projects upon which our experiences are based, as well as on the agile processes used for them. Following the brief discussion of goals and practices, this chapter will present the lessons learned from the successes and failures in practicing quality assurance in agile projects. We aim at informing fellow agile developers and researchers about our methods for achieving quality goals, as well as providing an understanding of the current state of quality assurance in agile practices.

Teaching Agile Software Development Quality Assurance

This chapter presents a teaching framework for agile quality—that is, the way quality issues are perceived in agile software development environments. The teaching framework consists of nine principles, the actual implementation of which is varied and should be adjusted for different specific teaching environments. This chapter outlines the principles and addresses their contribution to learners’ understanding of agile quality. In addition, we highlight some of the differences between agile software development and plan-driven software development in general, and with respect to software quality in particular. This chapter provides a framework to be used by software engineering instructors who wish to base students learning on students’ experiences of the different aspects involved in software development environments.

Requirements Specification using User Stories

Collecting and analyzing user requirements is undoubtedly a really complicated and often problematic process in software development projects. There are several approaches, which suggest ways of managing user’s requirements; some of the most well-known are IEEE 830 software requirements specification (SRS), use cases, interaction design scenarios, etc. Many software experts believe the real user requirements emerge during the development phase. By constantly viewing functional sub-systems of the whole system and participating, in fact, in all phases of system development, customers/users can revise their requirements by adding, deleting, or modifying them. However, in order for this to become possible, it is important to adopt a totally different approach than the traditional one (waterfall model approach), concerning not only the management of user’s requirements, but also the entire software development process in general. Agile methodologies represent this different approach since the iterative and incremental way of development they propose includes user requirements revision mechanisms and user active participation throughout the development of the system. The most famous approach concerning requirements specification among the supporters of the agile methodologies is probably user stories. User stories and their main characteristics are thoroughly demonstrated in this chapter. After reading this chapter, the authors hope that the reader may have gained all the basic understanding regarding the use of user stories.

What's Wrong with Agile Methods? Some Principles and Values to Encourage Quantification

Current agile methods could benefit from using a more quantified approach across the entire implementation process (that is, throughout development, production, and delivery). The main benefits of adopting such an approach include improved communication of the requirements, and better support for feedback and progress tracking. This chapter first discusses the benefits of quantification, then outlines a proposed approach (Planguage), and finally describes an example of its successful use (a case study of the “Confirmit” product within a Norwegian organization, “FIRM”).

Agile Quality or Depth of Reasoning? Applicability vs. Suitability with Respect to Stakeholders' Needs

This chapter provides a basis for discussion and analysis of the quality characteristics of the agile information systems development (AISD) process, and exposes concerns raised regarding the applicability and suitability of agile methods in different organisational and national cultures. The arguments are derived from recent literature reviews and reports on the state-of-the-art in agile methodologies. We also reflect on our own research and experience in three European countries with different academic and work values, and information systems development (ISD) industrial practices based on diverse principles. Examining the different perceptions of quality in the agile software development paradigm by comparing and contrasting them to the quality perceptions in the established ISD methodological paradigms, we aim at: (i) exploring the relationship of traditional, agile, managed, and measured ISD processes, (ii) making the human dynamics that bear on the success and consensus acceptance of IS more explicit, and (iii) establishing a critical framework/approach for reflecting on the suitability and applicability of agile methods in the development and management of quality software systems.