Book notes: Design It!: From Programmer to Software Architect
Tags: books, architecture, career
Published: 2023-03-28 21:54:33

---
title: Book notes: Design It!: From Programmer to Software Architect
published: true
tags: books, architecture, career
canonical_url: https://danlebrero.com/2022/05/04/design-it-book-summary/
cover_image: https://danlebrero.com/images/blog/books/design-it/design-it.jpg
series: Book notes
description: Book notes on "Design It!: From Programmer to Software Architect" by Michael Keeling
---

These are my notes on [Design It!: From Programmer to Software Architect](https://amzn.to/3q8oElm) by [Michael Keeling](https://twitter.com/michaelkeeling).

"From Programmer to Software Architect" is a spot on subtitle.

# Key Insights

* SW design is a constant struggle to find the right balance between the things you want and the reality you must accept.
* Every team has at least one architect. The best teams have several.
* For every SW system you build, briefly describe the system and what you learned during your time developing it.
* Design Thinking Principles (From [Design Thinking: Understand – Improve – Apply](https://amzn.to/3taqfJb)):
    1. All design is social in nature: for and with people.
    1. Preserve ambiguity:
        * Minimalist architecture:
            * [Less is More with Minimalist Architecture](https://www.bredemeyer.com/pdf_files/MinimalistArchitecture.PDF).
    2. All design is redesign.
    3. Make ideas tangible to facilitate communication.
* Emphasize:
    1. Treat solutions as experiments.
    1. Focus on reducing risks.
    1. Work to simplify problems.
    1. Iterate quickly to learn quickly.
    1. Think about the problem and solution at the same time.
* [Use risk to decide what to focus on.](#risk)
* Architecturally Significant Requirements:
    1. Constraints:
        * Well-chosen constraints simplify the problem.
        * Early design decisions can become constraints in the future.
    2. Influential functional requirements:
        * Identifying influential functional requirements is equal part of art and science.
    3. Quality Attributes.
    3. Others:
        * Tech trends.
        * Architecture skills, knowledge.
        * Team skills, knowledge.
        * Team organization.
* Our confidence in a decision increases after seeing multiple alternatives.
* Decision matrix: Do not use numbers as they give a false sense of confidence and precision.
* Complexity is an inevitable by-product of every successful software system.
* Discussion lacking in disagreement may seem like positive progress, but it is more likely to be the opposite.
* Sometimes a simple table is all that is needed.
* Precision gets in the way of communication: accurate, not precise.
* A good-looking document tells readers the content is trustworthy and was created by a professional.
* Sometimes your pile of rejected decisions can be more telling than a lengthy explanation.
* Keep design authority when risks of failure are high.
* The discussion is often more important than the option picked.
* [Empathy map](https://medium.com/the-xplane-collection/updated-empathy-map-canvas-46df22df3c8a).
* [The Agile Inception Deck](https://agilewarrior.wordpress.com/2010/11/06/the-agile-inception-deck/).

# All activities

### Understand

| Activity | Time | Participants | Notes |
| --- |--- |--- |--- |
| Choose one thing | | All stakeholders | Clear prioritization and disagreement. |
| Empathy map | 10-30m | Solo or 3-5. Devs + Arch | For the team to develop empathy. |
| Goal-Question-Metric workshop | 15-90m | 1-5 people. | Prioritized metrics to gather. |
| Interview stakeholders | 30-60m per interview | 1-2-1 or small stakeholder group | |
| List assumptions | 15-30m | Whole team in 2-5 groups | Take assumptions out of the shadows. |
| Mini-Quality attributes workshop | 90-180m | Arch + 3-5 stakeholders | |
| Point-of-View mad lib | 30-45m | 1-3 people. Any stakeholder | Summarize business goals and other needs. |
| Response measure straw man | Combine with other | Architect prepares | Get conversation moving. |
| Stakeholder map | 30-45m | 1-25. Whole team + stakeholders | Relations and interactions.|

### Explore

| Activity | Time | Participants | Notes |
| --- |--- |--- |--- |
| Personify the architecture | | |It is ok to feel silly.|
| Architecture flip book | 30-45m | 1-3 people | Record all steps on design iteration.|
| Component responsibility collaborator cards | 30-90m | Solo or 3-5 | Propose architectural elements. |
| Concept map | 30-60m | 1-3 technical stakeholders | Uncover missing domain concepts. |
| Divide and conquer |  | Groups of 2-4 | To cover a lot of ground in parallel. |
| Event Storming | 90m | 2-12. Expert + dev team | Identify domain events. |
| Group Posters | 20-30m | Groups 2-5 people | To summarize outcomes. |
| Round-Robin design | 15-45m | 3-12 tech stakeholders | Combine ideas + build consensus. |
| Whiteboard Jam | Up to the group | 3-5 tech stakeholders | |

### Make

| Activity | Notes |
| --- | --- |
| Architecture Decision Records | |
| Architecture haiku| One-page uber-terse summary |
| Context diagram | Agreement with system scope|
| Greatest hits reading list | |
| Inception deck | 10 important questions at the start of a new project |
| Modular decomposition diagram | Tree diagram that shows relationships at different granularities |
| Paths not taken| |
| Prototype to learn or decide| |
| Sequential diagram| |
| System metaphor | |

### Evaluate

| Activity | Time | Participants | Notes |
| --- |--- |--- |--- |
| Architecture Briefing | 45-60m preparation. 30m present. 30m questions | Arch + wide audience | |
| Code review | Ongoing | 2 to whole team | |
| Decision Matrix | Varies | Arch + Stakeholders | |
| Observer Behaviour | | | Observability in production |
| Question-Comment-Concern | 30-90m | Whole team | |
| Risk storming | 60-90m | 3-7 devs | |
| Sanity Check | 5-10m | Whole team| Pop quiz|
| Scenario walk-through | 20-30m per quality attribute | 3-7 people | Use early |
| Sketch and Compare | 20-30m | 3-5 people | |

<br/>

# TOC

* [Part I - Introducing Software Architecture](#part-1)
    * [Chapter 1 - Become a Software Architect](#ch-1)
    * [Chapter 2 - Design Thinking Fundamentals](#ch-2)
* [Part II - Architecture Design Fundamentals](#part-2)
    * [Chapter 3 - Devise a Design Strategy](#ch-3)
    * [Chapter 4 - Empathize with Stakeholders](#ch-4)
    * [Chapter 5 - Dig for Architecturally Significant Requirements (ASR)](#ch-5)
    * [Chapter 6 - Choose an Architecture (Before It Chooses You)](#ch-6)
    * [Chapter 7 - Create a Foundation with Patterns](#ch-7)
    * [Chapter 8 - Manage Complexity with Meaningful Models](#ch-8)
    * [Chapter 9 - Host an Architecture Design Studio](#ch-9)
    * [Chapter 10 - Visualize Design Decisions](#ch-10)
    * [Chapter 11 - Describe the Architecture](#ch-11)
    * [Chapter 12 - Give the Architecture a Report Card](#ch-12)
    * [Chapter 13 - Empower the Architects of Your Team](#ch-13)
* [Part III - The Architect's Toolbox](#part-3)
    * [Chapter 14 - Activities to Understand the Problem](#ch-14)
    * [Chapter 15 - Activities to Explore Potential Solutions](#ch-15)
    * [Chapter 16 - Activities to Make the Design Tangible](#ch-16)
    * [Chapter 17 - Activities to Evaluate Design Options](#ch-17)

# <a name="part-1"></a>Part I - Introducing Software Architecture

## <a name="ch-1"></a>Chapter 1 - Become a Software Architect

* What architects do?
    1. Define the problem from an engineering perspective.
    1. Partition the system and assign responsibilities.
    1. Keep an eye on the bigger picture:
        * System as a whole.
        * SW design is a constant struggle to find the right balance between the things you want and the reality you must accept.
    1. Decide trade-offs among quality attributes.
    1. Manage technical debt.
    1. Grow the team's architecture skills:
        * Architecture design is a social activity.
* A system's software architecture is the set of significant design decisions about how the software is organized to promote desired quality attributes and other properties.
* Software structure's elements and relations:
    1. Module: structure that exists at design time (class, DB table).
    1. Component and connector (C&C): exits at runtime (object, process).
    1. Allocations: how modules and C&C elements correspond to each other.
        * Aka: mapping structures.
* Quality attribute is any externally visible characteristic by which stakeholders judge a SW system's goodness.
* Every team has at least one architect. The best teams have several.
* For every SW system you build, briefly describe the system and what you learned during your time developing it.

## <a name="ch-2"></a>Chapter 2 - Design Thinking Fundamentals

* Design thinking: problem-solving approach that puts humans at the center.
* Principles (From [Design Thinking: Understand – Improve – Apply](https://amzn.to/3taqfJb)):
    1. All design is social in nature:
        * For and with people.
    1. Preserve ambiguity:
        * Minimalist architecture:
            * [Less is More with Minimalist Architecture](https://www.bredemeyer.com/pdf_files/MinimalistArchitecture.PDF).
            * Only focus on how high-priority quality attributes are achieved.
    1. All design is redesign.
    1. Make ideas tangible to facilitate communication.
* To design an architecture:
    1. Pick a mindset.
    1. Pick a practice within that mindset.
    1. Apply practice to learn something new.
    1. Goto (1).
* Design mindsets:
    1. Understand:
        * Requires empathy.
    1. Explore.
    1. Make.
    1. Evaluate.

# <a name="part-2"></a>Part II - Architecture Design Fundamentals

## <a name="ch-3"></a>Chapter 3 - Devise a Design Strategy

* Emphasize:
    1. Treat solutions as experiments.
    1. Focus on reducing risks.
    1. Work to simplify problems.
    1. Iterate quickly to learn quickly.
    1. Think about the problem and solution at the same time.
* How much design up front:
    * Barry Boehm, Architecting: how much and when. Chapter 10 of [Making Software](https://amzn.to/3JS2POT).
    * Total project time == dev time + architecture + rework.
    * Architecture reduces rework time.
    * Bigger systems benefit the most from more up-front architecture work.
    * [COSYSMO](http://cosysmo.mit.edu) and [COCOMO II](https://en.wikipedia.org/wiki/COCOMO).
* <a name="risk"></a>Use risk to decide what to focus on:
    * [conditions] might [consequences]
    * Deal with risk:
        1. Reduce probability.
        1. Reduce impact.
        1. Push out the time frame of the risk.
        1. Remove condition.
        1. Accept it and do nothing.
    * Which mindset:
        * Understand: risk is about problem.
        * Explore: risk is about solution.
            * Have you seen enough solution alternatives?
        * Make: risk is about communication.
            * Do stakeholders fully understand design and architecture?
        * Evaluate: risk involves a design decision or the design's overall fit.
            * Do we need to make a design decision?
* Create a design plan.

## <a name="ch-4"></a>Chapter 4 - Empathize with Stakeholders

* Create a stakeholder map with stakeholders, stakeholders groups and their relationship.
* Record business goal statements:
    * Subject, outcome, context.
    * Outcome: measurable.
    * Context: insightful and not obvious.
* Most systems only have three to five business goals.

## <a name="ch-5"></a>Chapter 5 - Dig for Architecturally Significant Requirements (ASR)

* 4 Categories:
    1. Constraints:
        * Unchangeable. Non-negotiable.
        * Well-chosen constraints simplify the problem.
        * Technical: programming lang, platforms, components, technology.
        * Business: team structure, schedule, budget, legal.
        * Early design decisions can become constraints in the future.
        * Keep a XLS: constraint, origin, type, context.
    1. Influential functional requirements (FR):
        * Identifying influential functional requirements is equal part of art and science.
        1. Sketch notional architecture.
        1. Identify classes of requirements:
            * Group FR with the same architecture elements (like persistence).
            * FR that seem difficult to implement.
            * High-value, high-priority FR.
        1. Try each class of requirements against the notional architecture:
            * If it is not obvious how to implement, the it might be an influential FR.
    1. Others:
        * Tech trends.
        * Architecture skills, knowledge.
        * Team skills, knowledge.
        * Team organization.
    1. Quality Attributes:
        * Use quality attribute scenarios:
            * Parts:
                * Stimulus: event that triggers the scenario.
                * Source: who.
                * Artifact: part of the system.
                * Response: externally visible action by the artifact as result of the stimulus.
                * Response measure (Success criteria, Specific and measurable).
                * Environment context: "normal", peak load, failure condition.
                * Keep in XLS:

| Quality Attribute | Scenario | Priority |  
| --- | --- | --- | 
| Availability | When DB does not respond, respond with stale data within 3 secs | high | 
| ... | ... | ... | 

* Build an architect significant requirements doc:
    * Purpose and scope.
    * Intended audience.
    * Business context.
    * Quality attribute requirements:
        * Top scenarios.
    * Influential FR:
        * Top users or user persona.
        * Use cases or user stories.
    * Appendix A: Glossary.
    * Appendix B: Quality Attributes Taxonomy.

## <a name="ch-6"></a>Chapter 6 - Choose an Architecture (Before It Chooses You)

* Our confidence in a decision increases after seeing multiple alternatives.
* You need to explore:
    1. Architecture elements and their responsibilities.
    1. How elements interact with each other. Their interfaces.
    1. Understand the domain.
    1. Tech and framework that promote quality attributes.
    1. How app will be deployed.
    1. Look at past designs.
* Decision matrix:
    * I personally like text + color (red, white, green).
    * Do not use numbers as they give a false sense of confidence and precision.

| | Option A | Option B | Option C |
| --- | --- |--- |--- |
| Property 1 | promotes | + | <i class="fas fa-arrow-up"></i> |
| Property 2 | inhibits | \- | <i class="fas fa-arrow-down"></i> |
| Property 3 | neutral | o | <i class="fas fa-arrow-right"></i> |

* Create an element responsibility catalog:
    * Assign to each element the influential functional requirement.

## <a name="ch-7"></a>Chapter 7 - Create a Foundation with Patterns

* See [Fundamentals of Software Architecture](https://danlebrero.com/2021/11/17/fundamentals-of-software-architecture-summary/#content).

## <a name="ch-8"></a>Chapter 8 - Manage Complexity with Meaningful Models

* Complexity is an inevitable by-product of every successful software system.
* Abstractions help us focus on specific details at the expense of others.
* Good architecture models:
    * Establish the vocabulary of design.
    * Direct attention to interesting details.
    * Allows to reason about quality attributes.
    * Captures the architect's intention.
* Design a meta-model: concepts and rules to use those concepts.
* Building models into the code:
    * It is possible to shrink the model-code gap, but it cannot be closed completely.
    1. Use architecture vocabulary.
    1. Organize code following architecture elements.
    1. Enforce relations, so that it becomes impossible to violate the architecture.
    1. Add comments.

## <a name="ch-9"></a>Chapter 9 - Host an Architecture Design Studio

* Design studio encourages group collaboration and has strict time constraints to help the team see a broad range of ideas in a short time frame.
* Creates buy-in of everybody involved.
* Outcomes:
    * Things to make.
    * Things to research more.
    * New open questions.
* Typically, few hours to a day.
* Steps:
    1. Prepare:
        * Business and workshop goals.
        * Quality attributes.
        * ASRs.
        * Choose participants:
            * 3-10.
            * Diverse background.
        * Discussion lacking in disagreement may seem like positive progress, but it is more likely to be the opposite.
    1. Kick-off:
        * Share context.
    1. Create:
        * Choose design activity:
            * [Tell-show-tell](http://mydemolife.blogspot.com/2008/12/tell-show-tell-technique-what-else.html) to explain the activity.
            * Time boxed. Minimum 5 mins.
    1. Share:
        * 3-5 mins.
        * Only main points.
        * No questions or comments.
    1. Critique:
        * Specific.
        * Focus on facts.
        * Point also good things.
    1. Iterate:
        * Go to 3.
        * Tweak the group dynamics.
    1. Close:
        * Reflect.
        * Decide specific actions.
* Use a parking lot to record interesting ideas for other time, and keep the workshop moving.

## <a name="ch-10"></a>Chapter 10 - Visualize Design Decisions

* Sometimes a simple table is all that is needed.
* Sometimes precision gets in the way of communication:
    * Accurate, not precise.
* Tips:
    * Always include a legend.
    * Add a descriptive title.
    * Highlight patterns.
    * Be consistent.
    * Provide descriptive prose, and/or text annotations.

## <a name="ch-11"></a>Chapter 11 - Describe the Architecture

* Which architecture description approach should I use?<br/>
  ![describe architecture](https://danlebrero.com/images/blog/books/design-it/describe-architecture.jpg)
* Tribal:
    * Oral tradition, informal sketching, story telling.
* Communal:
    * When you find yourself telling the same story to more than a few people.
    * Architecture Haiku, ADR, architecturally evident coding style.
* Formal:
    * High-risk systems or architecture decisions.
    * Traditional SW architecture decision (SAD).
    * Templates:
        * [SEI views and beyond](https://resources.sei.cmu.edu/library/asset-view.cfm?assetid=484159).
        * [ISO/IEC/IEEE 42010](https://en.wikipedia.org/wiki/ISO/IEC_42010).
* Always keep the audience in mind:
    * Use [empathy map](https://www.nngroup.com/articles/empathy-mapping/).
* A good-looking document tells readers the content is trustworthy and was created by a professional.
* Establish viewpoints:
    * Arch from the point of view of a related set of stakeholder concerns.
    * Example standard viewpoints:
        * SEI views and beyond.
        * Simon Brown's [C4 model](https://c4model.com/).
        * Phillipe Krutchen's [4+1 view model](https://ieeexplore.ieee.org/document/469759).
    * Usually organized around quality attributes or stakeholder needs.
* Explain rationale:
    * Sometimes your pile of rejected decisions can be more telling than a lengthy explanation.

## <a name="ch-12"></a>Chapter 12 - Give the Architecture a Report Card

* Benefits of evaluation:
    * Educate team.
    * Create buy-in.
    * Reduce delivery risks.
    * Improve architecture.
* Design Rubric:
    * 2 parts:
        1. Criteria:
            * ASR as a guide.
            * Important, essential, distinct, observable and measurable, precise and unambiguous.
        1. Rating:
            * Select scale:
                * 1-2: all or nothing. Few reviewers.
                * 1-3: minimum acceptable threshold. Multiple reviewers.
                * 1-4: Detailed feedback desired.
            * Discuss any "1" score, even if the average is acceptable.
* Organize an architecture evaluation workshop:
    * Steps: prepare, prime reviewers, assess, analyze, follow-up.
    * It is important to understand why the design is fit (or not).
    * Great designs can always be improved.
    * Gold standard:
        * [ATAM](https://en.wikipedia.org/wiki/Architecture_tradeoff_analysis_method).
        * See [Software Architecture in Practice](https://amzn.to/3f7XMLS).
        * Multi-day or multi-week.
* Evaluate early, often, continuously:
    * Risks.
    * Unknowns.
    * Problems.
    * Gaps.
    * Arch erosion.
    * Contextual drift.
* Start with low ceremony methods.

## <a name="ch-13"></a>Chapter 13 - Empower the Architects of Your Team

* Modern SW dev teams need a different kind of leader than the traditional top-down architect.
    * Coach, mentor, technical guru.
* Teams who embrace the idea of SW architect as a way of thinking instead of as a role, produce better SW:
    * More eyes.
    * Team buy-in. Ownership.
* Create opportunities for safe practice:
    * Pair design.
    * Create scaffolding:
        1. Build templates for delegated work.
        1. Provide feedback during peer reviews.
        1. Create checklists.
    * Introduce architectural guide rails:
        * Guide rails (constraints) decreases the chances to mess up the architecture.
    * Host information sessions.
* Keep design authority when risks of failure are high.

## <a name="part-3"></a>Part III - The Architect's Toolbox

## <a name="ch-14"></a>Chapter 14 - Activities to Understand the Problem

1. Choose One Thing:
    * Discuss priorities by presenting an extreme choice.
    * If you only get one thing, what will it be?
    * Clear prioritization.
    * Clear disagreement.
    * The discussion is often more important than the option picked.
    * Use early.
2. Empathy Map:
    * Brainstorm and record responsibilities, thoughts and feelings for the team to develop empathy.
    * [Updated version](https://medium.com/the-xplane-collection/updated-empathy-map-canvas-46df22df3c8a).
3. Goal-Question-Metric Workshop:
    * Identify metrics and response measures to connect data with business goals.<br/>
      ![goal-question-metric](https://danlebrero.com/images/blog/books/design-it/goal-question-metric.png)
    * Question to answer to know if we have met the goal.
    * Result: prioritized data and metrics to gather.
4. Interview Stakeholders:
    * Unstructured interviews should still have a checklist.
5. List assumptions:
    * Take assumptions out of the shadows.
    * Write down everything mentioned, even obvious ones.
    * Pause to discuss surprising assumptions.
6. Mini-Quality Attribute workshop:
    * Prepare:
        1. Quality attribute taxonomy (max 7).
        2. Quality attribute scenario templates.
        3. Quality attribute web.
        4. As homework, refine top raw quality scenarios. Present in a follow-up meeting.
1. Point-of-View Mad Lib:
    * Summarize business goals and other needs.
    * Template:<br/>
      ![point of view mad lib](https://danlebrero.com/images/blog/books/design-it/point-of-view-mad-lib-template.png)
    * Consensus is not required.
    * Outcome focused.
1. Response Measure Straw Man:
    * Give stakeholders something to beat up until they arrive at their own answers.
    * Response either:
        * Honest: if you are confident.
        * Outrageous: to find boundaries.
1. Stakeholder Map:
    * To visualize relationships, hierarchies and interactions between people involved or impacted by the system.
    * Once completed ask who are the most important stakeholders.

## <a name="ch-15"></a>Chapter 15 - Activities to Explore Potential Solutions

1. Personify the architecture:
    * Give it human qualities so that you can explore interactions among elements.
    * How it "reacts" or "feel", make it memorable through story telling.
    * It is ok to feel a little silly.
2. Architecture flip book:
    * Record every step of the design journey so others can follow along afterwards.
    * Sketch + notes about incremental changes.
    * Teach others how to think about design and modeling.
    * On a slide deck, keep copying the last slide and editing it.
3. Component responsibility collaborator cards:
    * Propose architectural elements, their responsibilities and how they come together to form a view of the architecture.<br/>
      ![crc card](https://danlebrero.com/images/blog/books/design-it/crc-card.png)
4. Concept map:
    * Visualize how concepts in the domain relate to one another.
    * Helps to uncover missing, hidden, or implied domain concepts.
5. Divide and conquer:<br/>
   ![divide and conquer](https://danlebrero.com/images/blog/books/design-it/divide-and-conquer.png)
    * Tight feedback loops work better.
6. Event Storming:
    * Collaborative brainstorming technique used to identify domain events.
    * To better engage subject-matter experts.
    * Concrete and specific examples, not abstract.
7. Group Posters:
    * Create a poster that conveys their design ideas for the architecture outcomes.
    * To summarize outcomes.
8. Round-Robin design:
    * Quickly explore a range of ideas, and then combine to start building consensus.
    * Steps:
        1. Sketch 5m.
        2. Rotate.
        3. Critique 3m.
        4. Rotate.
        5. Improve 5m.
        6. Review all sketches.
9. Whiteboard Jam:
    * Collaboratively draw diagrams on a whiteboard.
    * Pictures won't make sense to someone who wasn't there.

## <a name="ch-16"></a>Chapter 16 - Activities to Make the Design Tangible

1. Architecture Decision Records:
    * Capture architecture design decisions using a lightweight text-based template.
1. Architecture haiku:
    * Create bit-sized architecture summaries that stakeholders will actually use.
    * Think through and articulate the essential parts.
1. Context diagram:
    * Help stakeholders understand where the software system fits in the world.
    * Agreement with system scope.
1. Greatest hits reading list:
    * Help navigate the morass of design artifacts, so they can find relevant information.
    * Links list with tile, overview and caveats.
1. Inception deck:
    * Answer 10 important questions at the start of a new project to avoid common failures and align stakeholders.
    * [The Agile Inception Deck](https://agilewarrior.wordpress.com/2010/11/06/the-agile-inception-deck/)
    * Customize questions to your context.
    * Effort to create should be proportional to size and cost of project.
1. Modular decomposition diagram:
    * Simple tree diagram that shows how abstractions at different granularities are related.
    * Root is the whole system.
    * Child are more and more specific.
1. Paths not taken:
    * List options discarded with a brief explanation of why.
1. Prototype to learn or decide:
    * Always prototype as quickly and cheaply as possible.
1. Sequential diagram.
1. System metaphor.

## <a name="ch-17"></a>Chapter 17 - Activities to Evaluate Design Options

* Evaluation is a continuous activity.
1. Architecture Briefing:
    * Brief presentation on some part of the architecture, to get meaningful feedback.
1. Code review:
    * From architecture point of view.
1. Decision Matrix:
    * Visual comparison of alternatives.
    * No more than 7 factors.
    * No more than 5 design options.
    * Take notes when filling the matrix.
1. Observe Behaviour:
    * Add instrumentation to see runtime behaviours.
1. Question-Comment-Concern:
    * Collaborative, visual activity to shine light on knowledge gaps, articulate issues, and establish known facts about the architecture.
    * Team puts sticky notes (comments, questions, concerns) on views of the architecture.
1. Risk storming:
    * Collaborative, visual technique for identifying risks in the architecture.
1. Sanity check:
    * To expose issues in team communication or understanding.
    * Pop quiz-like.
1. Scenario walk-through:
    * Describe step-by-step how the architecture addresses a specific quality attribute scenario.
    * Use early.
    * Avoid problem-solving during the session.
    * Architect + note taker + session moderator + few reviewers. 3-7 total.
1. Sketch and Compare:
    * Create two or more alternatives of the same design, so it is easier to see the pros/cons.
    * Always summarize the findings.