Skip to main content
main-content
Top

About this book

Overview and Goals The agile approach for software development has been applied more and more extensively since the mid nineties of the 20th century. Though there are only about ten years of accumulated experience using the agile approach, it is currently conceived as one of the mainstream approaches for software development. This book presents a complete software engineering course from the agile angle. Our intention is to present the agile approach in a holistic and compreh- sive learning environment that fits both industry and academia and inspires the spirit of agile software development. Agile software engineering is reviewed in this book through the following three perspectives: l The Human perspective, which includes cognitive and social aspects, and refers to learning and interpersonal processes between teammates, customers, and management. l The Organizational perspective, which includes managerial and cultural aspects, and refers to software project management and control. l The Technological perspective, which includes practical and technical aspects, and refers to design, testing, and coding, as well as to integration, delivery, and maintenance of software products. Specifically, we explain and analyze how the explicit attention that agile software development gives these perspectives and their interconnections, helps viii Preface it cope with the challenges of software projects. This multifaceted perspective on software development processes is reflected in this book, among other ways, by the chapter titles, which specify dimensions of software development projects such as quality, time, abstraction, and management, rather than specific project stages, phases, or practices.

Table of Contents

1. Introduction to Agile Software Development

Abstract
What is agile software developmentagile software development? Why is an agile perspective on software engineering needed? What are the main characteristics of agile software development? What can be achieved by agile software development processesagile? Does agile software development form a pleasant and professional software development environment? These are the main questions addressed in this introductory chapter of the book. After reading this chapter, not only will you gain some insights about agile software development in general, you will also understand the nature of agile software development and be able to clarify how it establishes a professional software development environment in which software engineers are able to express their skills and, at the same time, to produce quality software products. In the section that deals with the learning of agile software development, we launch the development of a software project, describe the studiostudio as the development workplace, and explain the development schedule. The ideas presented in this chapter are further elaborated in the following chapters of the book.
Orit Hazzan, Yael Dubinsky

2. Teamworkteamworkteamwork

Abstract
This chapter presents one of the basic elements of software projects—teamwork. It addresses how to build teams in a way that promotes team members’ accountability and responsibility, and that fosters communicationcommunication between teammates. One of the basic ways to start team building is by assigning roles to the team members. For this purpose a role scheme is presented in this chapter, according to which each team member is in charge of a specific managerial aspect of the development process, such as design and continuous integration, in addition to his or her development tasks. Teamwork is not always a simple process, and sometimes it raises dilemmas and conflicts between team members. This aspect of teamwork is not neglected in agile teams, and when a conflict emerges, it is addressed openly by all the team members. In the section that deals with teamwork in learning environments, it is illustrated how the role schemerole and the discussion about dilemmasteamwork in teamwork provide an evaluation framework for software projects developed by student teams in academia.
Orit Hazzan, Yael Dubinsky

3. Customers and Users customer customer user user

Abstract
Customers have a key role is agile software development processes. The Agile ManifestoAgile Manifesto statement “customer collaborationcustomer over contract negotiation” explicitly suggests alternative work relationships with the customer, in which the customer is part of the team, rather than an entity with whom team members and management argue about what should be developed and when, and what should not be developed at all. This chapter describes the customer role in agile development environments and how to enhance communication with the customer. In many cases, the customer also represents the user group and is expected to evaluate the software product from the user perspective. This, however, turns out to be an ineffective mechanism in many cases. Accordingly, this chapter also describes the users’ role and presents a mechanism to increase their involvement and feedback during the development process. Specifically, data obtained from user evaluations is used to refine the user interface design, to increase product usability, and, consequently, to increase product quality.
Orit Hazzan, Yael Dubinsky

4. Time Time Time

Abstract
Time is addressed differently by different people and cultures; for example, in western cultureculture, time is mainly associated with financial profit, i.e., “Time is money.” Time plays a special role in software engineering: the project schedule should be met, the product should be delivered on time, teammates should complete their tasks on time, and so on. This chapter deals with how the time concept is expressed in software engineering in general and in agile software development in particular. In agile software development time is boxed for each activity, and when needed, instead of “moving” deadlines, the scope is changed according to customer priorities. This conception is supported by agile software development methods in different ways that not only enable one to work at a sustainable pace, but that also result in high quality products.
Orit Hazzan, Yael Dubinsky

5. Measuresmeasuresmeasures

Abstract
There is a consensus that the controlcontrol and managementmanagement of any process and activity can be improved by using measures to monitor its performance. In general, software engineering is a discipline that acknowledges products measures as well as measures of the development process. Specifically, the agile approach promotes a constant tracking during the entire process of software development. For example, the team velocity explained in Chapter 4, Time, is one of the important ways to control the project’s progress. Further, the tracker role is responsible for the definition and refinement of the team measures, for the collection of the required data, and for the measure presentation. Some measures are presented daily, like the daily progress within the iteration; some measures are presented every iteration, like code coverage or iteration progress within the release; yet other measures are presented every release, like customer satisfaction or level of product testability. By using measures on a regular basis, all teammates and stakeholders can view them, give feedback, and suggest refinements, and thus become accountable for the project development.
Orit Hazzan, Yael Dubinsky

6. Quality

Abstract
High quality assurance is a fundamental element of every engineering process and is considered to be one of the more difficult things to achieve and sustain. Since high quality is also a basic concern of software engineering, there are values and practices that support the assurance of high quality software products and processes. However, these are not sufficient, and in many cases, software products lack the required quality. In this chapter, among other issues, we analyze why this happens. We also describe how quality is perceived using the agile approach, starting withvalues values and practicespractices that support and control the process quality, such as customer collaboration and the planning of a typical agile software development process. We continue with values and practices that support the product quality, for example, refactoring and the feedback gained by exhaustive testing and test automation. Finally, we focus on the test driven developmentTest Driven Development (TDD)TDD practice, analyze its acceptance by software developers and present a way to measure and control TDD processes.
Orit Hazzan, Yael Dubinsky

7. Learning learning learning

Abstract
Software development is a learning processsoftware development process. This statement can be explained both from the customers’ and team members’ perspectivesperspective perspective. At the beginning of the development process customers do not know explicitly and entirely what their requirements for the developed product are, but improve their understanding with respect to these requirements during the development process. The team members keep improving their understandingunderstanding of the customer requirementsrequirements as well as of the developed product. If software development is a learning process, an appropriate learning environment should be provided to all project stakeholders. Indeed, this is another characteristic of agile software development environments—they support leaning processes. This aspect is explored in this chapter by an examination of agile software development environments from the constructivistconstructivist perspectiveperspective.
Orit Hazzan, Yael Dubinsky

8. Abstractionabstractionabstraction

Abstract
Software development is a complex task. Abstraction is one means used for reducing the complexity involved in software product development. One way by which abstraction is expressed is by removing details in order to simplify and capture a concept, finding a common denominator for generalizationgeneralization. Though abstraction is a useful tool, it is not always used; sometimes it is just difficult to think abstractly, and sometimes abstraction is not utilized due to a lack of awareness of its significance and its potential contribution. This chapter describes how abstraction is expressed in agile software development environments. Specifically, software designsoftware design and architecturearchitecture are abstractions used in this chapter to discuss the concepts of simple design and refactoringrefactoring. In addition, we revisit subjects that have been introduced in earlier chapters of the book and analyze them from the perspective of abstraction.
Orit Hazzan, Yael Dubinsky

9. Trusttrusttrust

Abstract
Software is an intangible productsoftware. Therefore, it is difficult to understand its development process using our regular senses; the exact status of the development process is not always clear; misunderstandings may emerge. Consequently, it is sometimes difficult to establish trustful professional relationships, and team members may tend not to trust each other. This chapter focuses on how agile software development fosters trust among team members. We first explain how agile software development makes the development process more transparent and thus makes the process and the developed product more understandable. Then, using the “prisoner’s dilemma”prisoner's dilemma framework taken from game theorygame theory, we explain why and how a transparent process does indeed foster trust among team members. Based on this working assumption, i.e., that the transparent nature of agile software development fosters trust among team members, we focus on how agile software development enhances ethicalethics behavior and diversitydiversity in a way that improves process and product quality.
Orit Hazzan, Yael Dubinsky

10. Globalization

Abstract
In this chapter we address the concept of agility in a wider context. One topic on which we focus is globalization in terms of distributed teamsdistributed teams; the second idea is the application of the agile approach for the managementmanagement of non-software projectsnon-software projects project. Agile software development has evolved significantly during the last decade. In parallel to this evolution, globalization in software development has also emerged, and software is developed in many cases by teams which are spread across geographical areas, cultures, and nationalities. This reality, called global software development, has advantages as well as disadvantages. The most obvious advantage is the business aspect of cost reduction; the most problematic issues are communication and team synchronization. In this chapter we briefly describe the notion of global software development and explain how some agile practices help cope with the challenges involved. Specifically, we will see that the agile approach encourages a transparent global software development process. thus increasing information flow and project visibility and assistings in solving communication and synchronization problems. Further, the tightness of agile processes simplifies software project management. We also examine in this chapter the notion of agility beyond the software world and discover its usefulness in such projects
Orit Hazzan, Yael Dubinsky

11. Reflectionreflectionreflection

Abstract
This chapter describes the notions of reflection and retrospectiveretrospective: reflection usually refers to the individual’s thinking about what he or she has accomplished; retrospective is usually conducted in teams, and is partially based on the individuals’ reflections performed during the retrospective sessions. In fact, you, the readers, are familiar with and have experienced these notions at the end of the first iteration of the book, in Chapter 7, Learning, both individually and on the team level. Indeed, since these concepts are not trivial to grasp, it is preferred that learners experience them first, before the theoretical ideas are presented. This chapter, which closes the second iteration of the book, serves as an opportunity to understand the theory behind these concepts as well as to add some practical details about their actual performance.
Orit Hazzan, Yael Dubinsky

12. Change

Abstract
Coping with changechange is one of the main challenges of software engineering. This challenge encourages agile software developers to establish a development process that enables them to cope successfully with changes introduced during that process, while keeping the high quality of the product. This chapter focuses on change introduction into organizations that plan to transit, or that are already in the transition, to agile software development. Specifically, we present an evolutionary frameworkevolutionary framework for coping with change, using it for understanding a transition to agile development. We also suggest several methods to use in such a transition process, such as an organizational survey and a condensed workshop format on agile software development.
Orit Hazzan, Yael Dubinsky

13. Leadership

Abstract
Leadership is the ability to influence people, encouraging them to behave in a certain way in order to achieve the group’s goalsgoals. Leadership is independent of job titles and descriptions; usually, however, in order to lead, leaders need the power derived from their organizational positions. There are different leadership stylesleadership, such as task-oriented versus people-oriented, directive versus permissive, autocratic versus democratic. While leaders can shape their leadership style according to circumstances, followers might prefer different leadership styles depending on their situation. Agile software engineering adopts a leadership style that empowers the people involved in the product development process. For example, instead of promoting the idea that “leaders should keep power to themselves in order not to lose it,” the agile approach fosters the idea that “leaders gain power from sharing it.” This idea is expressed, among other ways, by the transparency of the agile development process that makes information accessible to anyone and enables each team member to be accountable for and fully involved in the development process.
Orit Hazzan, Yael Dubinsky

14. Delivery and Cyclicality delivery and cyclicality delivery and cyclicality

Abstract
This chapter describes the cyclic nature of the agile software developmentagile software development process, which is composed of releases, each of which first, ends with the product delivery to the customer and a reflective process; and second, signals the beginning of the next release. We focus on the delivery of a product, to the development of which the entire release has been dedicated, describing what happens in agile software development at the end of the releaserelease—the delivery, as well as just before and just after it. Specifically, prior to the deliverydelivery, the customer examines the product and checks its fitness to his or her expectation; then, the product release is celebrated; finally, after the delivery, a reflective session is facilitated to explore the lessons learned during the release for the improvement of future developments. We also summarize in this chapter the teaching and learning principles presented throughout the book.
Orit Hazzan, Yael Dubinsky
Additional information