Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Software Architecture in Practice

Software Architecture in Practice

Turn vague quality goals into testable designs, while containing costly changes and failures.
by Len Bass 2021 464 pages
3.85
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat architecture as a model for reasoning, not a diagram to admire

Architecture selects useful facts. The book defines software architecture as the structures that let people reason about a system: its elements, their relationships, and relevant properties. It is an abstraction, not a complete blueprint of every implementation detail. Three structural lenses answer different questions: modules show how code is divided, component-and-connector structures show runtime interactions, and allocation structures map software to hardware, files, or teams.

One system, several truths. A two-module client-server program could run as ten clients and one server, producing eleven runtime components. The module view helps organize code and changes; the runtime view helps analyze load and network traffic. Document only views that help someone make a decision or do their job.

Analysis

The useful analogy is not a building blueprint, but a set of maps: a subway map and a street map simplify the same city for different journeys. Architecture documentation works when it preserves the distinctions needed for a question and suppresses irrelevant detail. The risk is mistaking a tidy diagram for reality. If the code, runtime behavior, and team assignments diverge from the documented views, the model becomes misleading rather than clarifying.

Turn vague quality wishes into scenarios someone can actually test

Make requirements observable. A quality attribute scenario is a concrete statement of what happens when a particular actor or system triggers an event, under specified conditions, affecting a defined part of the system. It also states the desired response and a measurable threshold. “The system must be fast” becomes a requirement such as a specified number of requests completing within a stated time under peak load.

Find the consequential requirements. An architecturally significant requirement, or ASR, is one valuable enough to stakeholders and consequential enough to change the architecture. The authors recommend eliciting scenarios with stakeholders, connecting them to business goals, and ranking their value and technical risk. A hospital system’s patient update requirement matters more when its acceptable response time and operating conditions are explicit.

Analysis

Scenario writing is a form of negotiated measurement. It converts disagreements disguised as adjectives into choices that can be discussed: which users, what workload, what failure conditions, and what counts as acceptable. That discipline also exposes competing definitions of success. A single average response time, for instance, may hide poor experiences for a small but important group. A useful scenario is not merely measurable; it represents a stakeholder concern worth paying to satisfy.

Choose architecture for measured quality goals, because every shortcut moves a cost

Quality is designed in. Functionality says what responsibilities a system performs; quality attributes describe how well it performs them, such as speed, availability, security, safety, or ease of change. Architectural decisions shape these qualities, but rarely improve every one at once. Patterns are recurring solutions that bundle multiple decisions. Tactics are more focused design choices that influence a particular response, such as limiting retries or replicating a service.

Fitness depends on purpose. A layered architecture may help portability and change, yet add runtime overhead. Redundancy can improve availability while increasing cost and complexity. The book illustrates availability with a practical measure: 99.999 percent uptime still allows about 5 minutes and 15 seconds of unscheduled downtime per year. A design is good only relative to prioritized requirements and constraints.

Analysis

This is a strong antidote to architecture fashion. A pattern is not a badge of sophistication; it is a package of consequences. The deeper implication is that quality discussions should include the cost of achieving a target and the quality sacrificed to get it. Metrics help make that negotiation concrete, though they can create false precision. A measured threshold is useful only when the workload, environment, and stakeholders behind it are credible.

Design interfaces for meaning, timing, and resources, not just compatible data types

An API is not the whole contract. Integration can fail even when software elements can call one another successfully. The book distinguishes several kinds of mismatch: syntax, such as incompatible data types; data meaning, such as feet versus meters; behavior, such as different expectations about who initiates a request; timing, such as one component producing data at the wrong rate; and resources, such as components competing for limited memory or bandwidth.

The Mars Climate Orbiter shows the stakes. NASA lost the spacecraft after teams exchanged acceleration data using different measurement systems. The data could be transmitted and parsed, but the assumptions behind it did not match. Architects can reduce such risks by documenting semantics and operating assumptions, using standards, encapsulating volatile details, and inserting adapters or mediators when components cannot be changed.

Analysis

The distinction between connection and compatibility is essential in systems assembled from vendors, legacy software, and independently managed services. A successful API call proves only that a message crossed a boundary, not that both sides understood its meaning or could honor its timing and resource demands. This resembles organizational handoffs: shared forms do not guarantee shared interpretation. Interfaces therefore need enough context to expose assumptions, while avoiding promises about implementation details that should remain changeable.

Make common changes local, and make releases reversible before users find defects

Design for the system after launch. The book notes that much software expense occurs after initial delivery, as teams add features, fix defects, and adapt to new platforms. It distinguishes local changes, which affect one element, from nonlocal changes that touch several, and architectural changes that alter the system’s fundamental structure. Good modular boundaries aim to keep likely changes local. High cohesion keeps related responsibilities together; low coupling limits the ripple effects of change.

Deployment is an architectural quality. A deployment pipeline automates building, testing, staging, and release. Gradual rollouts, rollback mechanisms, feature toggles, and consistent dependency packaging help limit the damage from a bad release. Containers can make deployments lighter than full virtual machines, but they share an operating-system kernel and have different isolation and compatibility constraints.

Analysis

Reversibility changes the economics of experimentation. A team that can expose a new feature to a small group, observe its behavior, and switch it off has a safer learning loop than one forced to make every release all-or-nothing. Yet automation cannot repair a poor boundary: a nominally independent service may still require coordinated data or protocol changes. Deployment design is therefore not merely operations work. It depends on interfaces, state ownership, testing, and the ability to distinguish versions safely.

Treat safety as a system behavior, not a software checkbox

Failures become hazards through context. Safety concerns preventing the system from entering states that can cause injury, damage, or loss of life, and limiting harm when they occur. Hazards can follow missing, spurious, mistimed, or incorrect events. The authors recommend identifying hazards first, then designing ways to detect them, contain their effects, and recover or move into a safe mode.

Human feedback matters. In 1983, Soviet officer Stanislav Petrov judged a computer warning of incoming missiles to be false, preventing a possible escalation. In Air France flight 447, unreliable airspeed readings and confusing stall warnings contributed to pilots making the wrong response. These cases show why redundant sensors, independent checks, clear alerts, controlled degradation, and manual fallback must be designed together.

Analysis

The examples make safety a property of a human-machine system, not a defect count in code. An alarm can be technically accurate and still unsafe if its timing, presentation, or implied action misleads an operator. Redundancy helps only when channels fail independently; copies built from the same mistaken assumptions can repeat the same error. Safety design therefore benefits from analyzing the whole chain, from sensor and software through interface, training, and operator decision.

Plan for cloud slowness and energy limits, not just average-case capacity

Distributed systems have long tails. In one set of 1,000 cloud instance-launch requests described in the book, the median took 23 seconds, while the 95th percentile took 57 seconds. Averages can conceal these slow outliers. Timeouts, health checks, load balancers, stateless services, and carefully chosen retries help manage delay and failure, but aggressive retries can worsen congestion. Replicas and autoscaling add capacity, while also adding coordination and operating costs.

Energy is another scarce resource. Mobile devices must adapt to battery level, network availability, and sensor costs; cloud data centers must manage large aggregate consumption. Architects can measure or estimate energy use, reduce unnecessary work, and power down idle resources. Any energy saving must be weighed against latency, availability, and usability.

Analysis

The long-tail example challenges a common engineering instinct: optimize the typical request and treat the rest as noise. In distributed systems, a small share of very slow calls can dominate user experience or block a chain of dependent services. Percentiles and workload-specific scenarios are therefore more informative than one average. Energy adds an important systems-level constraint: reducing computation can save power, but moving work to a cloud may simply shift consumption elsewhere rather than eliminate it.

Sketch the design, test its riskiest assumptions, and document why choices were made

Design in deliberate rounds. Attribute-Driven Design, or ADD, is a repeatable method for turning prioritized requirements into structures. Each design iteration focuses on selected requirements, chooses suitable concepts such as patterns or technologies, assigns responsibilities, defines interfaces, and records a sketch and rationale. Prototypes are useful when evidence about a technology or quality target is weak, but should answer a specific question rather than become accidental production foundations.

Evaluate before commitments harden. The Architecture Tradeoff Analysis Method, or ATAM, examines high-priority scenarios, identifies risky decisions, and makes tradeoffs visible. Documentation should use different views for different audiences: developers need module and interface detail, while analysts may need runtime and deployment behavior. In one review story, an architecture diagram prompted users to notice unresolved behavior that ordinary requirements presentations had missed.

Analysis

The value of these practices is not ceremony but early information. ADD makes design work inspectable, and evaluation makes disagreement productive before it becomes expensive rework. Documentation also preserves rationale, not just boxes and arrows, so future teams can distinguish deliberate constraints from forgotten accidents. The caution is proportionality: a small, short-lived application may not justify a full formal review. The right investment scales with the cost of being wrong and the uncertainty being resolved.

Use change history to find architectural debt that code review cannot see

Look for costly relationships. Architecture debt is the maintenance burden created by problematic structural relationships, such as cycles, unstable interfaces, or modules that repeatedly change together despite having no clear dependency. The book’s method compares source-code dependencies with co-change patterns from version history and bug data. A design structure matrix, or DSM, displays these relationships so clusters of problematic files become visible.

Quantify the case for repair. In a reported project, three hotspots involved 291 of 797 files and accounted for 89 percent of the project’s defects. Refactoring them was estimated to require 14 person-months, while the projected annual savings exceeded 41 person-months. That estimate depends on assumptions, but it turns “this code feels painful” into a business case that managers can examine.

Analysis

This approach treats maintenance history as evidence about design, rather than as a pile of unrelated tickets. Co-change is especially revealing because it can expose hidden coupling that static diagrams miss. The figures also illustrate a practical argument for refactoring: concentrate effort where defect and change activity cluster. Still, correlation is not proof that architecture caused every bug. Teams should inspect the hotspots and validate that the proposed redesign addresses the mechanisms producing the cost.

Align team boundaries with software boundaries, because every dependency creates coordination work

Architecture organizes people too. Module boundaries often shape team assignments, schedules, testing, and communication. If teams own tightly dependent modules, every change can require negotiation across organizational lines. This is especially costly in distributed development, where informal conversations are scarce. Microservices can support independent releases, but only when interfaces, data ownership, and operational responsibilities genuinely permit independence.

Use intentional design without freezing it. The book’s compromise with Agile is to make early decisions about major risks and boundaries, then revise them through increments and time-limited technical experiments as requirements change. Architects also need business knowledge, technical judgment, communication skills, and mentorship. The quantum-computing coda offers one final design instinct: isolate technologies likely to change, especially cryptography, rather than assume today’s implementation will last forever.

Analysis

This is the book’s most organizational insight: architecture is also a theory of how work and knowledge will be divided. Conway’s law describes the pressure for system structure to reflect communication structure, but that relationship is not destiny; deliberate interfaces and coordination practices can counter unhelpful boundaries. Agile delivery does not remove the need for design, it changes its cadence. The strongest architecture is neither a frozen master plan nor a structure left entirely to emerge by accident.

Analysis

The book’s central contribution is a practical way to reason from organizational purpose to technical structure. It resists two comforting myths: that architecture is merely a high-level diagram, and that a modern platform or framework makes architectural judgment unnecessary. Instead, an architecture is a selective model whose usefulness depends on the questions it supports. The same system needs different views for code ownership, runtime behavior, deployment, and stakeholder communication.

Its strongest method is to connect quality goals to specific scenarios, then connect scenarios to design choices and evidence. That chain makes architecture discussable: a team can ask what a requirement means, which decision supports it, what tradeoff it introduces, and how to test the claim. The approach is especially valuable for qualities that are otherwise easy to wave at, such as security, safety, or “modularity.”

The book also expands the architect’s remit beyond technology. Interfaces create dependencies; dependencies create coordination costs; and team structure can either amplify or dampen those costs. Documentation, release discipline, and architecture evaluation are therefore not administrative accessories. They are mechanisms for retaining knowledge and controlling risk across people and time.

A useful qualification is that structured methods can create an illusion of certainty. Scenarios and models improve precision, but they cannot make uncertain workloads, business priorities, or failure assumptions certain. Metrics can also reward what is easy to count rather than what stakeholders value. Architecture should therefore be treated as an evolving hypothesis, checked against operational evidence and revised when its assumptions fail. The book’s broad lesson is not “design everything upfront.” It is to make consequential decisions visible early, test the riskiest ones, and preserve enough flexibility to learn.

Summary in 30 Seconds
Translate quality goals into measurable scenarios that specify conditions, system response, and thresholds. Choose structures for prioritized needs, since improving availability, speed, security, and ease of change can introduce competing costs. Clear interface contracts must account for meaning, timing, and resource limits, not just compatible data. Use prototypes to test risky assumptions, and make releases reversible. Change history can reveal architectural hotspots: one project’s three hotspots covered 291 of 797 files and 89 percent of defects.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.85 out of 5
Average of 500+ ratings from Goodreads and Amazon.

Software Architecture in Practice receives mixed reviews, with an average rating of 3.86/5. Readers appreciate its comprehensive coverage of software architecture concepts, quality attributes, and practical techniques. Many find it valuable for understanding architect responsibilities and system design. However, some criticize its length, repetitiveness, and theoretical focus. The book is praised for bridging theory and practice, but some feel it's outdated or too focused on large-scale systems. Overall, it's considered a solid reference for software architects and students, though potentially overwhelming for beginners.

Your rating:
4.39
291 ratings
Want to read the full book?

Glossary

Architecturally significant requirement

Requirement that shapes architecture

An architecturally significant requirement, or ASR, is a requirement whose presence is likely to change the architecture substantially. It usually matters strongly to business or mission goals and often concerns a demanding quality attribute. Architects identify ASRs through requirements review, stakeholder conversations, and business-goal analysis, then use them to guide design and evaluation.

Quality attribute scenario

Testable quality requirement

A quality attribute scenario describes a concrete event and the system response required under stated conditions. It identifies who or what causes the event, what is affected, the relevant environment, and how the response will be measured. Scenarios turn vague goals such as “secure” or “fast” into requirements that stakeholders can prioritize and architects can assess.

Component-and-connector structure

Runtime elements and interactions

A component-and-connector structure represents a system while it is running. Components are units with runtime behavior, such as services, clients, servers, or data stores. Connectors describe how those components interact, through mechanisms such as calls, messages, or shared data. This view supports reasoning about runtime behavior, including performance, availability, security, and concurrency.

Architectural tactic

Decision targeting a quality response

An architectural tactic is a focused design decision that influences how a system responds to a particular stimulus, especially with respect to a quality attribute. Examples include adding a timeout to detect an unresponsive service or replicating a component to reduce the effect of failure. Tactics can be combined into broader patterns and refined for a system’s context.

Attribute-Driven Design

Iterative architecture design method

Attribute-Driven Design, or ADD, is a method for creating architecture through iterative decisions guided by prioritized requirements, especially quality attribute scenarios. In each iteration, the architect selects requirements and elements to address, chooses appropriate design concepts, assigns responsibilities, defines relationships and interfaces, records the design, and checks whether the goal was met. The method can support incremental project development.

Architecture Tradeoff Analysis Method

Stakeholder-centered architecture evaluation

The Architecture Tradeoff Analysis Method, or ATAM, is a structured process for evaluating whether an architecture can meet its important quality requirements. Stakeholders and evaluators examine prioritized scenarios against the design, identify decisions that create risk, and expose sensitivity points where a choice strongly affects an outcome. The process also reveals tradeoffs when improving one quality may weaken another.

Architecture debt

Costly structural design burden

Architecture debt is the accumulated maintenance burden caused by problematic relationships among system elements. It may appear as cyclic dependencies, unstable interfaces, or modules that repeatedly change together despite lacking an explicit dependency. The book describes identifying it by combining source-code structure, revision history, and issue data, then prioritizing refactoring where these patterns correlate with high change or defect costs.

Utility tree

Prioritized quality scenario map

A utility tree organizes a system’s quality goals from broad attributes to specific requirements expressed as scenarios. Each scenario can be assessed for business value and technical risk, helping architects decide which concerns deserve the most design and evaluation effort. It is useful when stakeholder input is incomplete and provides a structured record of the quality goals believed to matter.

FAQ

What's Software Architecture in Practice about?

  • Comprehensive Overview: Software Architecture in Practice by Len Bass provides a detailed exploration of software architecture, emphasizing its critical role in software development.
  • Quality Attributes Focus: It discusses how architecture influences quality attributes like performance, security, and modifiability, linking them to business goals.
  • Practical Methods: The book introduces methods such as the Attribute-Driven Design (ADD) and Architecture Tradeoff Analysis Method (ATAM) to guide architects in designing and evaluating architectures.

Why should I read Software Architecture in Practice?

  • Essential Knowledge: Understanding software architecture is crucial for software engineers, as it directly impacts project success.
  • Real-World Applications: The book offers practical advice and case studies, making it relevant for both students and professionals.
  • Industry Insights: Authors provide insights based on extensive experience, aligning with current industry practices and challenges.

What are the key takeaways of Software Architecture in Practice?

  • Architecture's Importance: The book emphasizes that architecture is vital for achieving quality attributes and managing change effectively.
  • Quality Attribute Scenarios: It introduces scenarios to specify and analyze quality requirements, aiding in informed design decisions.
  • Tactics and Patterns: A catalog of tactics and patterns is provided to enhance system performance, security, and modifiability.

What is the definition of software architecture according to Software Architecture in Practice?

  • Set of Structures: Software architecture is defined as "the set of structures needed to reason about the system," focusing on relationships and properties.
  • Reasoning Tool: It serves as a tool for reasoning about functionality and quality attributes, encompassing ongoing design considerations.
  • Abstraction: Architecture is an abstraction, emphasizing public interfaces and relationships while managing complexity.

What is the Attribute-Driven Design (ADD) method in Software Architecture in Practice?

  • Systematic Approach: ADD guides architects through the design process, focusing on achieving specific quality attributes.
  • Iterative Steps: It involves steps like reviewing inputs, selecting design concepts, and defining interfaces, ensuring alignment with requirements.
  • Quality Focus: The method prioritizes quality attributes, helping architects create effective and efficient designs.

How does Software Architecture in Practice define quality attributes?

  • Non-Functional Requirements: Quality attributes are non-functional requirements like performance, security, and usability, crucial for system success.
  • Scenarios for Clarity: Quality attribute scenarios illustrate how attributes will be measured and achieved, aiding in design understanding.
  • Balancing Trade-offs: The book discusses trade-offs between attributes, emphasizing careful balancing to meet stakeholder needs.

What is the Architecture Tradeoff Analysis Method (ATAM) in Software Architecture in Practice?

  • Evaluation Framework: ATAM evaluates architectures based on quality attribute scenarios, identifying risks and trade-offs.
  • Collaborative Process: It involves presenting the architecture, identifying goals, and analyzing scenarios with stakeholder engagement.
  • Valuable Outputs: The method produces insights like risks and recommendations, guiding informed architectural decisions.

How does Software Architecture in Practice address the concept of modifiability?

  • Ease of Change: Modifiability is the "ease with which changes can be made," crucial for reducing costs and risks.
  • Enhancing Tactics: Tactics like increasing cohesion and reducing coupling are provided to design adaptable systems.
  • Trade-offs Consideration: Achieving modifiability involves trade-offs with other attributes, requiring careful design decisions.

What are some tactics for achieving availability in software systems according to Software Architecture in Practice?

  • Fault Detection: Tactics include monitoring system health and implementing heartbeat checks to identify faults early.
  • Fault Recovery: Strategies like using redundant spares and rollback mechanisms maintain availability during failures.
  • Preventing Faults: Proactive measures, such as removing components from service, enhance overall system availability.

How does Software Architecture in Practice suggest handling long tail latency in cloud systems?

  • Understanding the Phenomenon: Long tail latency refers to requests taking longer than average, impacting performance.
  • Hedged Requests: Issuing multiple requests and canceling unnecessary ones ensures timely processing.
  • Alternative Requests: Additional requests for slow responses help maintain performance in unpredictable conditions.

What are the best quotes from Software Architecture in Practice and what do they mean?

  • "Architecture is a means to an end.": Highlights that architecture's purpose is to deliver stakeholder value by meeting needs.
  • "Design is hard.": Reflects the complexity of creating effective architectures, navigating trade-offs and uncertainties.
  • "Documentation is a love letter you write to your future self.": Emphasizes thorough documentation for understanding and maintenance.

How does Software Architecture in Practice suggest managing architecture debt?

  • Identifying Hotspots: Use design structure matrices to find architecture debt hotspots that increase maintenance costs.
  • Quantifying Debt: Analyze revision history and issue tracking to quantify debt, justifying refactoring efforts.
  • Refactoring Strategies: Implement specific strategies to address debt, improving architecture quality and reducing costs.

About the Author

Len Bass is a renowned expert in software architecture and co-author of "Software Architecture in Practice." He has dedicated his career to researching, teaching, and advancing the field of software architecture. Bass has extensive experience working with the Software Engineering Institute (SEI) at Carnegie Mellon University, where he contributed significantly to developing software architecture methodologies and practices. His work focuses on improving software quality, performance, and maintainability through effective architectural design. Bass is widely respected in the software engineering community for his contributions to the discipline and his ability to bridge theoretical concepts with practical applications in software development.

Download PDF

To save this Software Architecture in Practice summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.41 MB     Pages: 20

Download EPUB

To read this Software Architecture in Practice summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.39 MB     Pages: 25
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 25,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...