Software Architecture in Practice, 2nd Edition

Software Architecture in Practice, 2nd Edition

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 59 Lessons (9h 55m) | 2.72 GB

Now thoroughly updated, Software Architecture in Practice LiveLessons introduces students to the most important aspects of software architecture: what it is and what it is not, why it is important, how it affects project success, and how it can be managed in a professional way.

The basic principle of software architecture is that every software system is constructed to satisfy an organization’s business goals, and the architecture of a system is a bridge between the (often abstract) business goals and the final (concrete) resulting system. The path from abstract goals to concrete systems is often complex. In this video training, Rick Kazman shows how software architectures can be designed, analyzed, and documented with techniques that support the achievement of these business goals.

The course covers requirements (quality attributes) that drive architecture, and how to elicit, prioritize, and characterize them precisely and unambiguously. It covers patterns and tactics (the building-blocks of architecture) and a method of architecture design called Attribute Driven Design (ADD). It also presents the Architecture Tradeoff Analysis Method (ATAM), which is used to analyze and understand strengths and weaknesses of designed (or inherited) architectures. The course wraps up with practical advice on how to blend architecture activities with agile methodologies and how to be an agent for change in an organization.

Updates to this video include a deep dive into the distinct quality attributes of Availability, Modifiability, Performance, and Deployability, as well as expanded discussions on the intersection of agile and software architecture, and new discussions on DevOps and technical debt. Lessons 1, 2, and 7-9 are thoroughly updated; Lessons 3-6 and 10 are new to the second edition.

Learn How To

  • Understand and communicate the importance of architecture
  • Elicit and validate architectural requirements, particularly quality attribute requirements
  • Design architectural structures to meet quality attribute requirements
  • Analyze an architecture

Lesson 1: Defining Software Architecture: This lesson defines what software architecture is and is not, and explores the implications thereof. It covers the ways in which software architecture is important and the basics of documenting an architecture in terms of architectural views. Finally, it discusses the importance of patterns and tactics, and gives tips for how to distinguish a good architecture.

Lesson 2: Architecture Requirements: Quality Attributes: This lesson shows how to distinguish functionality from quality attributes, to unambiguously specify quality attribute requirements, and to recognize other important requirements that drive an architecture.

Lesson 3: Availability: This lesson teaches how to think about availability, specify availability requirements, understand availability tactics, and design patterns that you can use to achieve high levels of availability.

Lesson 4: Modifiability: This lesson shows how to clearly state what modifiability is from an architectural perspective, how to specify modifiable requirements in a precise testable fashion, and teaches design tactics and patterns to achieve modifiability.

Lesson 5: Performance: This lesson covers how to create architectures that are fast and predictable. It teaches how to think about performance, specify performance requirements, and use design tactics and patterns to achieve the best performance as an architect.

Lesson 6: Deployability: This lesson focuses on systems for which just-in-time feature releases are significant competitive advantages and just-in-time bug fixes are essential for the safety and security of continuous operation. It covers deployability scenarios, and design tactics and patterns to achieve deployability.

Lesson 7: Gathering Architectural Requirements: This lesson covers problems in eliciting actionable architectural requirements and how to remedy this problem via the Quality Attribute Workshop (QAW) and the Quality Attribute Utility Tree.

Lesson 8: Creating the Architecture: This lesson presents the Attribute-Driven Design (ADD) method, which aids in designing an architecture, and walks through the steps of the ADD method.

Lesson 9: Architecture Analysis: This lesson describes forms of architecture evaluation, and looks closely at a specific architecture evaluation method called the Architecture Tradeoff Analysis Method (ATAM). It teaches the steps of ATAM and introduces a lightweight variant. It also introduces using tactics-based questionnaires as a form of analysis.

Lesson 10: Architectures, Agility, and Technical Debt: This lesson covers the concepts of Agile and the relationship between agility and architecture. It provides guidelines for Agile architects and shows how to detect and fix architectural/design debt.

Table of Contents

1 Software Architecture in Practice Introduction

Lesson 1 Defining Software Architecture
2 Learning objectives
3 What is software architecture
4 Why is architecture important
5 Why and how to document an architecture
6 What makes a “good” architecture
7 Summary

Lesson 2 Architecture Requirements Quality Attributes
8 Learning objectives
9 What are architectural requirements
10 How to specify quality attributes
11 How to gather quality attribute requirements
12 How to achieve quality attributes
13 Summary

Lesson 3 Availability
14 Learning objectives
15 What is Availability
16 How to specify Availability scenarios
17 What are Availability tactics
18 What are Availability patterns
19 Summary

Lesson 4 Modifiability
20 Learning objectives
21 What is Modifiability
22 How to specify Modifiability scenarios
23 What are Modifiability tactics
24 What are Modifiability patterns
25 Summary

Lesson 5 Performance
26 Learning objectives
27 What is Performance
28 How to specify Performance scenarios
29 What are Performance tactics
30 What are Performance patterns
31 Summary

Lesson 6 Deployability
32 Learning objectives
33 What is Deployability
34 How to specify Deployability scenarios
35 What are Deployability tactics
36 What are Deployability patterns
37 Summary

Lesson 7 Gathering Architectural Requirements
38 Learning objectives
39 What are the problems in eliciting actionable architectural requirements
40 What is the Quality Attribute Workshop
41 What is the Quality Attribute Utility Tree
42 Summary

Lesson 8 Creating the Architecture
43 Learning objectives
44 How should I design my architecture
45 What are the steps of ADD
46 What are the hard parts of ADD
47 Summary

Lesson 9 Architecture Analysis
48 Learning objectives
49 Should I analyze my architecture
50 How can I organize an ATAM
51 How do I conduct an ATAM
52 Are there lighter weight evaluation techniques
53 Summary

Lesson 10 Architectures, Agility, and Technical Debt
54 Learning objectives
55 How do agile concepts relate to architecture
56 What is design debt
57 How can I fix design debt
58 Summary

59 Software Architecture in Practice Summary