Agile Software Architecture

Aligning Agile Processes and Software Architectures

Muhammad Ali Babar, Alan W. Brown, Ivan Mistrik

• Publisher: Morgan Kaufmann
• Year: 2013
• ISBN:
  9780124078857
• Topic: Informatica
• Subtopic: Media digitali

Agile software development approaches have had significant impact on industrial software development practices. Today, agile software development has penetrated to most IT companies across the globe, with an intention to increase quality, productivity, and profitability. Comprehensive knowledge is needed to understand the architectural challenges involved in adopting and using agile approaches and industrial practices to deal with the development of large, architecturally challenging systems in an agile way.

Agile Software Architecture focuses on gaps in the requirements of applying architecture-centric approaches and principles of agile software development and demystifies the agile architecture paradox. Readers will learn how agile and architectural cultures can co-exist and support each other according to the context. Moreover, this book will also provide useful leads for future research in architecture and agile to bridge such gaps by developing appropriate approaches that incorporate architecturally sound practices in agile methods.

• Presents a consolidated view of the state-of-art and state-of-practice as well as the newest research findings
• Identifies gaps in the requirements of applying architecture-centric approaches and principles of agile software development and demystifies the agile architecture paradox
• Explains whether or not and how agile and architectural cultures can co-exist and support each other depending upon the context
• Provides useful leads for future research in both architecture and agile to bridge such gaps by developing appropriate approaches, which incorporate architecturally sound practices in agile methods

Chapter 1

Making Software Architecture and Agile Approaches Work Together

Foundations and Approaches

Muhammad Ali Babar, The University of Adelaide, Adelaide, SA, Australia

Abstract

Software architecture (SA) is one of the most significant areas of research and practice in software engineering. It has been shown that getting architecture of large-scale complex systems right is not only extremely important but hugely challenging. The increasing popularity and adoption of Agile Software Development (ASD) methods have brought architecture-centric methods and practices into question as agile followers tend to perceive architecture in the context of plan-driven software development. It is widely recognized that SA needs sufficient attention for successful development and evolution of software-intensive systems and services irrespective of the software development paradigm. Given the nature of the discipline, SA methods and approaches tend to be effort-intensive and heavyweight for certain kinds of projects. There is an increasing interest in finding ways to apply architecture-centric principles and practices in an Agile fashion—Agile architecting. A good understanding of architectural principles and approaches is a prerequisite to agile architecting. The aim of this chapter is to briefly describe the fundamental concepts, principles, and practices of architecture-centric approaches. These concepts, principles, and practices are expected to provide a reader with sufficient understanding of different aspects of SA and its related methods to combine them with ASD methods. We start with a brief discussion of the points that make architecture and agile approaches seemingly incompatible. Then we present and discuss some of the key aspects of architecture-centric approaches and techniques that need to be considered for use in ASD projects. We also provide an overview of some of the key practices that have been recommended for successfully integrating architecture-centric approaches in ASD for developing large-scale, software-intensive systems.

Keywords

Software engineering; Software architecture; Agile methods; Requirements engineering; Architecturally significant requirements; Personas; Scrum; Extreme programming (XP); Design patterns; Scenarios

Chapter Contents

1.1 Introduction

1.2 Software Architecture

1.2.1 Software Architecture Process and Architecture Lifecycle

1.2.2 Architecturally Significant Requirements

1.2.3 Software Architecture Design Methods

1.2.4 Documenting Software Architecture

1.2.5 Software Architecture Evaluation

1.3 Agile Software Development and Architecture

1.3.1 Scrum

1.3.2 Extreme Programming

1.4 Making Architectural and Agile Approaches Work

Acknowledgments

Acknowledgments

Some of the most significant contributions to my understanding and writings on this topic were made by Professor Philippe Kruchten and Professor Pekka Abrahamsson through sharing their writings, ideas, and experiences. Some of the ideas presented in this chapter came through my collaboration with Minna Pikkarainen and Toumas Ihme of VTT, Finland. This chapter also benefited from the knowledge that I gained from the articles submitted to our call to a special issue of IEEE Software back in 2009/2010. Kieran Conboy also helped in collecting the data. Some content is based on my research in the FLEXI ITEA2 project. I also acknowledge the generosity of my co-editors of this book for allowing me to author this chapter.

1.1 Introduction

The Agile software development (ASD) paradigm has been widely adopted by hundreds of large and small companies in an effort to reduce costs and increase their ability to handle changes in dynamic market conditions. Based on the principles of the Agile Manifesto,^a Agile practitioners have proposed several methods and approaches, such as Scrum [1], feature-driven development [2], extreme programming [3], and test-driven development. We refer to all of them as ASD methods in this chapter. While there is no doubt that there has been manifold increase in the adoption of ASD methods by all sorts of companies, there has always been a growing skepticism about the reliability, effectiveness, and efficiency of those ASD methods that do not pay sufficient attention to the important roles of SA-related principles, practices, and artifacts [4–6]. It has been widely recognized that SA can be an effective tool to cut development and evolution cost and time and to increase the conceptual integrity and quality of a system [7]. However, the followers of ASD methods view architecture-centric approaches as part of the plan-driven development paradigm [4]. According to them, upfront design and evaluation of SA as high ceremony activities are likely to consume a lot of time and effort without providing a system's customers with valuable deliverables (i.e., code for features). The proponents of SA believe that sound architectural practices cannot be followed using agile approaches.

It can be asserted that this situation has arisen from two extreme views of ASD methods and SA-centric methods. The supporters of architecture-centric approaches appear to be less convinced that any software-intensive system of a significant size can be successfully built and evolved without paying sufficient attention to architectural issues, especially in domains such as automotive, telecommunication, finance, and medical devices. The advocates of ASD methods appear to apply You aren't gonna need it thinking to architecture-centric activities (e.g., design, evaluation, documentation). According to them, refactoring can help fix most of a software-intensive system’s structural problems. It has been claimed that refactoring is worthwhile as long as the high-level design is good enough to limit the need for large-scale refactoring [6,8,9]. And many experiences show that large-scale refactoring often results in significant defects, which are very costly to address later in the development lifecycle.

Most of the descriptions of ASD methods pay very little attention to common architectural design activities [10], such as architectural analysis, architectural synthesis, architectural evaluation, and the artifact types [10] associated with these activities. Most of the ASD methods tend to assume that architectural design is high-level design without explicit structuring forces, such as quality attributes. Thapparambil [11] asserts that Refactoring is the primary method to develop architecture in the Agile world. The primary incremental design practice of the second edition of the XP book [3] claims that architecture can emerge in daily design. The emergent design means that architecture relies on looking for potentially poor architectural solutions in the implemented code and making a better architecture when needed through refactory. According to this approach, architecture emerges from code rather than some upfront structure.

It is beginning to be recognized that both disciplines (i.e., ASD methods and architecture-centric approaches) have important and complementary roles in software development and evolutionary activities. While ASD methods promise to enable companies to achieve efficiency, quality, and flexibility for accommodating changes, it is critically important to follow solid architectural practices for large-scale software development projects. There is also a growing recognition of the importance of paying more attention to architectural aspects in agile approaches [4–6,12].

This situation has stimulated several efforts aimed at identifying the mechanics and prerequisites of integrating appropriate architecture-centric principles and practices in ASD methods [4,8]. One of the main objectives of these efforts is to help practitioners to understand the contextual factors and reasons for paying attention—or not—to the role and importance of a system's SA when implementing ASD methods [8,13]. Researchers and practitioners have also identified the technical and organizational challenges involved in integrating Agile approaches in traditional software development methods [14,15]. However, while anecdotal evidence reveals that there are large organizations in the midst of agile transformation, and that the architectural issues are being addressed, there has been no significant effort to synthesize and present a reliable body of knowledge about the architecture-centric challenges faced by ASD projects and potential solutions to those challenges.

This book provides a unique and comprehensive body of knowledge about the challenges and opportunities for making agile and architectural approaches coexist when developing safety, business, security, or mission-critical, software-intensive systems and services. The body of knowledge presented in this book is expected to help companies and practitioners build their architectural capabilities in the context of ASD methods or enable architectural-centric companies to make their approaches and practices agile and lean. That means companies will be able to adopt ASD methods without compromising on the architectural aspects of their software-intensive systems. The theories and practical examples in this book will enable companies of all sizes and contexts to gain the expertise, knowledge, and technological know-how to combine the strengths and benefits of architectural and ASD methods to achieve their goals. Quality, productivity, and profitability can be increased by improving the efficiency and effectiveness of companies’ software development processes.

In the following sections and subsections, we briefly describe some of the well-known architecture-centric concepts and approaches and their origins and applicability contexts. It can be asserted that the SA-related concepts and principles described in this chapter can be tailored and integrated into ASD methods. Then we provide a brief description of two of the most popular ASD methods. And eventually, we discuss a few ways to integrate architecture-centric approaches in ASD methods.

1.2 Software Architecture

Software architecture is an important sub-discipline of software engineering. While SA’s important role in achieving the quality goals of a software-intensive system gained popularity during the 1990s, the idea of ensuring software quality through high-level design decisions emerged in the 1970s. Parnas showed how modularization and information hiding could be used as a means of improving a system’s flexibility and comprehensibility [16]. Soon after, Stevens et al. presented the idea of module coupling and cohesion as a characteristic of quality software design [17]. However, software engineers did not realize the importance of the relationship between non-functional requirements (NFRs) and SA design until the early 1990s. The practice of using design patterns and architectural styles for producing quality designs in short periods of time provided impetus for new interest in addressing quality issues at the architecture level [18–20].

Software architecture may mean different things for different people. It is difficult to claim that there is a widely accepted definition of SA in the software industry [21]. One of the first definitions of SA was provided by Perry and Wolf in their widely cited paper [22]. They define SA as follows:

According to this definition SA is a combination of (1) a set of architectural elements (i.e., processing, data, and connecting), (2) the...

Table of contents

• Cover image
• Title page
• Table of Contents
• Copyright
• Acknowledgments
• About the Editors
• List of Contributors
• Foreword by John Grundy: Architecture vs Agile: competition or cooperation?
• Foreword by Rick Kazman
• Preface
• Chapter 1. Making Software Architecture and Agile Approaches Work Together: Foundations and Approaches
• PART 1: Fundamentals of Agile Architecting
• PART 2: Managing Software Architecture in Agile Projects
• PART 3: Agile Architecting in Specific Domains
• PART 4: Industrial Viewpoints on Agile Architecting
• Author Index
• Subject Index