Front Cover -- Agile Software Architecture: Aligning Agile Processes and Software Architectures -- Copyright -- Contents -- Acknowledgments -- About the Editors -- Muhammed Ali Babar -- Alan W. Brown -- Ivan Mistrik -- List of Contributors -- Foreword by John Grundy Architecture vs Agile: competition or cooperation? -- Software Architecture-the ``Traditional ́́View -- Agile Methods-the ``Traditional ́́View -- Software Architecture-Strengths and Weaknesses with Regard to Agility -- Agile-Strengths and Weaknesses with Regard to Software Architecture -- Bringing the Two Together-Agile Architecting or Architecting for Agile? -- Looking Ahead -- References -- Foreword by Rick Kazman -- Preface -- Part I: Fundamentals of agile architecting -- Part II: Managing software architecture in agile projects -- Part III: Agile architecting in specific domains -- Part IV: Industrial viewpoints on agile architecting -- Chapter 1: Making Software Architecture and Agile Approaches Work Together: Foundations and Approaches -- 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 -- References -- Part 1: Fundamentals of Agile Architecting -- Chapter 2: The DCI Paradigm: Taking Object Orientation into the Architecture World -- 2.1. Introduction -- 2.1.1. Agile apologia -- 2.1.2. Architecture and DCI -- 2.2. The vision: what is architecture? -- 2.2.1. Why do we do architecture? -- 2.2.2. Into software -- 2.2.3. Why software architecture?.

2.2.4. Architecture and the agile agenda -- 2.2.5. DCI as an integrative view of the architecture metaphor -- 2.3. Form and function in architectural history -- 2.3.1. Historic movements and ideologies -- 2.3.2. Enter postmodernism -- 2.3.3. Architecture finds an object foothold -- 2.3.4. Software engineering and architecture today -- 2.3.5. Measures of the vision -- 2.4. What is object orientation? Achieving the vision -- 2.4.1. The Kay model -- 2.4.2. Mental system models -- 2.4.3. Model-view-controller -- 2.4.4. Patterns -- 2.4.5. Use cases -- 2.4.6. Many views of objects and the boundaries of MVC -- 2.5. Shortcomings of the models -- 2.5.1. The network paradigm -- 2.5.2. Model-view-controller -- 2.5.3. Patterns -- 2.5.4. Use cases -- 2.5.5. The object canon -- 2.5.5.1. Object-oriented programming isnt about classes -- 2.5.5.2. Class thinking isnt limited to class systems -- 2.5.5.3. Lack of locality of intentionality -- 2.5.5.4. Summary of the shortcomings -- 2.5.5.5. Epicycles: early visions of relief -- 2.6. DCI as a new paradigm -- 2.6.1. A DCI overview -- 2.6.1.1. Full OO -- 2.6.1.2. Restricted OO -- 2.6.1.3. Data, Context, and Interaction -- 2.6.2. Relating DCI to the original OO vision -- 2.6.2.1. How DCI achieves the vision of Restricted OO -- 2.6.2.2. How DCI overcomes the shortcomings of class-oriented programming -- 2.6.3. DCI and the agile agenda -- 2.7. DCI and architecture -- 2.7.1. DCI and the postmodern view -- 2.7.1.1. Ideas over objects -- 2.7.1.2. Compositional strategies over individual parts -- 2.7.1.3. A human-centric agenda -- 2.7.1.4. Focus on change -- 2.7.2. Patterns and DCI -- 2.7.3. DCI and the network computation view -- 2.7.4. Firmitas, utilitas, and venustas -- 2.8. Conclusion -- References -- Further Reading -- Chapter 3: Refactoring Software Architectures -- 3.1. Introduction -- 3.2. Dealing with design flaws.

3.3. Evolution and styles of refactoring-code refactoring -- 3.4. Evolution and styles of refactoring-refactoring to patterns -- 3.5. The motivation for software architecture refactoring -- 3.6. Architectural smells -- 3.7. A real-world example -- 3.8. Quality improvement -- 3.9. The process of continuous architecture improvement -- 3.10. Shallow and deep refactoring -- 3.11. Additional examples of architecture refactoring patterns -- 3.11.1. Breaking dependency cycles -- 3.11.2. Splitting subsystems -- 3.12. Known obstacles to architecture refactoring -- 3.13. Comparing refactoring, reengineering, and rewriting -- 3.14. Summary -- References -- Chapter 4: Driving Architectural Design and Preservation from a Persona Perspective in Agile Projects -- 4.1. Introduction -- 4.2. Personas in the design space -- 4.3. Discovering ASRs -- 4.3.1. From features to architectural concerns -- 4.3.2. Embedding architectural concerns into personas -- 4.4. Personas for driving architectural design -- 4.4.1. Goal analysis -- 4.4.2. Generating and evaluating architectural solutions -- 4.4.3. Examples -- 4.5. Personas and architectural preservation -- 4.5.1. Trace by subscription -- 4.5.2. Generating persona-centric perspectives -- 4.5.3. Examples -- 4.6. ASPs in other project domains -- 4.6.1. Mechatronics traceability -- 4.6.2. Online trading -- 4.6.3. Bond, James Bond -- 4.7. Conclusions -- Acknowledgments -- References -- Chapter 5: Architecture Decisions: Who, How, and When? -- 5.1. Introduction -- 5.2. Research methodology -- 5.3. The agile architecture axes framework -- 5.3.1. Who makes the architectural decisions? -- 5.3.2. What artifacts are used to document the decision? -- 5.3.3. What is the feedback loop of an architectural decision? -- 5.3.4. Summary of the axes -- 5.4. Industrial cases -- 5.4.1. Case Alpha -- 5.4.1.1. Phase one -- 5.4.1.2. Phase two.

5.4.1.3. Shifts -- 5.4.2. Case Beta -- 5.4.2.1. Phase one -- 5.4.2.2. Phase two -- 5.4.2.3. Shifts -- 5.4.3. Case Gamma -- 5.4.3.1. Phase one -- 5.4.3.2. Phase two -- 5.4.3.3. Shifts -- 5.4.4. Case Delta -- 5.4.4.1. Phase one -- 5.4.4.2. Phase two -- 5.4.4.3. Shifts -- 5.4.5. Case Epsilon -- 5.4.5.1. Phase one -- 5.4.5.2. Phase two -- 5.4.5.3. Shifts -- 5.4.6. Overview -- 5.5. Analysis -- 5.5.1. Mapping the cases to the Triple-A Framework -- 5.5.2. Identified problems -- 5.5.3. Summary -- 5.6. Reflection -- 5.6.1. Findings -- 5.6.2. Questions of validity -- 5.7. Related and future work -- 5.8. Conclusions -- Appendix. A visual representation of the case studies mapped on the Triple-A Framework -- References -- Part 2: Managing Software Architecture in Agile Projects -- Chapter 6: Supporting Variability Through Agility to Achieve Adaptable Architectures -- 6.1. Introduction -- 6.2. Background -- 6.2.1. Variability -- 6.2.2. Agility -- 6.3. Related Work -- 6.4. Challenges when combining variability and agility -- 6.5. Arguments for combining variability and agility -- 6.6. Agile-Inspired variability handling -- 6.6.1. Industrial context: Dutch e-government -- 6.6.2. Step 1: conduct initial variability analysis -- 6.6.3. Step 2: create initial architecture variability profile -- 6.6.4. Step 3: create architecture -- 6.6.5. Steps 4a and 4b: evaluate architecture -- 6.6.6. Step 5: implement initial architecture -- 6.6.7. Step 6: elicit new variability requirements -- 6.6.8. Step 7: revise architecture variability profile -- 6.6.9. Step 8: refactor architecture -- 6.7. Summary and conclusions -- Acknowledgments -- References -- Chapter 7: Continuous Software Architecture Analysis -- 7.1. Introduction -- 7.2. Software architecture analysis -- 7.3. Approaches to software architecture analysis -- 7.3.1. Architecture reviews.

7.3.2. Scenario-based evaluation methods -- 7.3.3. Architecture description languages -- 7.3.4. Dependency analysis approaches and architecture metrics -- 7.3.5. Architecture prototyping -- 7.3.6. Ad hoc analysis -- 7.4. Continuous software architecture analysis -- 7.4.1. CSAA and different kinds of architecture analysis -- 7.4.2. Approaches for continuous quality control (CQC) -- 7.4.3. Characteristics of CQC approaches -- 7.4.4. CSAA process -- 7.5. CSAA in existing approaches -- 7.6. CSAA and analysis goals -- 7.7. Experiences with an approach to CSAA -- 7.7.1. Validation -- 7.8. Findings and research challenges -- 7.9. Conclusion -- References -- Chapter 8: Lightweight Architecture Knowledge Management for Agile Software Development -- 8.1. Introduction -- 8.2. Challenges of agile architecture documentation -- 8.3. Supporting techniques for AKM in agile software development -- 8.3.1. Architecture evaluation methods, agility, and AKM -- 8.3.2. Advanced techniques for managing architectural repositories -- 8.4. Architecture practices in agile projects -- 8.4.1. Scrum framework -- 8.4.2. Architecting while using Scrum -- 8.5. Architectural information flow in industry -- 8.5.1. Interview setup -- 8.5.2. Results -- 8.5.3. General comments from interviewees -- 8.5.4. Limitations -- 8.6. AKM in Scrum -- 8.6.1. Big-up-front-architecture and sprint-zero architecting approaches -- 8.6.2. In-sprints architecting approach -- 8.6.3. Separated-architecture-team architecting approach -- 8.7. Related work -- 8.8. Conclusions -- Acknowledgments -- References -- Chapter 9: Bridging User Stories and Software Architecture: A Tailored Scrum for Agile Architecting -- 9.1. Introduction -- 9.2. Agile architecting -- 9.3. Case study: metering management system in electrical power networks -- 9.4. Agile architecting mechanisms.

9.4.1. Feature pool and feature tree of user stories.