TEMP. Check list

• ✅Lesson 137 - REST vs Messaging (posted April 25, 2022)

• ✅Lesson 136 - Managing Shared Database Changes (posted April 11, 2022)

• ✅Lesson 135 - Scalability Revisited (posted March 28, 2022)

• Lesson 134 - What is a Service? (posted March 14, 2022)

• ✅Lesson 133 - Stovepipe Architecture AntiPattern (posted February 28, 2022)

• ✅Lesson 132 - Architecture by Implication AntiPattern (posted February 14, 2022)

• ✅Lesson 131 - Microservices vs. Event-Driven Architecture (posted January 31, 2022)

• Lesson 130 - The Frozen Caveman AntiPattern (posted January 17, 2022)

• Lesson 129 - Assessing Architectural Risk (Part 3) (posted December 20, 2021)

• Lesson 128 - Assessing Architectural Risk (Part 2) (posted December 6, 2021)

• Lesson 127 - Assessing Architectural Risk (Part 1) (posted November 22, 2021)

• Lesson 126 - Is SOA Dead? (posted November 8, 2021)

• Lesson 125 - Managing Broad Bounded Contexts (posted October 25, 2021)

• Lesson 124 - The Challenges of Distributed Architectures (posted October 11, 2021)

• Lesson 123 - Composite Architecture Characteristics (posted September 27, 2021)

• Lesson 122 - When Should You Replace Your Architecture? (posted September 13, 2021)

• ✅Lesson 121 - Transacted Messages (posted August 30, 2021)

• Lesson 120 - Domain vs. Technical Partitioning (posted August 16, 2021)

• Lesson 119 - Why Enterprise Architecture Efforts Fail (posted August 2, 2021)

• Lesson 118 - Limiting Assumptions (posted July 19, 2021)

• ✅Lesson 117 - Accidental Complexity AntiPattern (posted July 5, 2021)

• Lesson 116 - Negotiation Tips for Software Architects (posted June 21, 2021)

• Lesson 115 - Email-Driven Architecture (posted June 7, 2021)

• Lesson 114 - Microservices vs Service-Based Architecture (posted May 24, 2021)

• Lesson 113 - Cart Before The Horse Anti-Pattern (posted May 10, 2021)

• Lesson 112 - Architecture Characteristics Worksheet (posted April 26, 2021)

• Lesson 111 - CAP Theorem Illustrated (posted April 12, 2021)

• Lesson 110 - The Pros and Cons of Event-Driven Architecture (posted March 29, 2021)

• ✅Lesson 109 - BASE Transactions and Eventual Consistency (posted March 15, 2021)

• Lesson 108 - The Role of a Software Architect (posted March 1, 2021)

• Lesson 107 - Microservices Annotations and Attributes (posted February 15, 2021)

• Lesson 106 - Architecture Stories (posted February 1, 2021)

• ✅Lesson 105 - Stamp Coupling (posted January 18, 2021)

• Lesson 104 - Architecture Styles FAQ #1 (posted January 4, 2021)

• Lesson 103 - Balancing Architecture and Hands-On Coding (posted December 21, 2020)

• Lesson 102 - Architecture Characteristics FAQ (posted December 7, 2020)

• Lesson 101 - Components and Root Namespaces (posted November 23, 2020)

• Lesson 100 - My Architecture Journey: Lessons Learned (posted November 9, 2020)

• Lesson 99 - Enterprise Architecture Roadmaps: Priority Model (posted October 26, 2020)

• Lesson 98 - Enterprise Architecture Roadmaps: Portfolio Model (posted October 12, 2020)

• Lesson 97 - Enterprise Architecture Roadmaps: Iteration Model (posted September 28, 2020)

• Lesson 96 - Enterprise Architecture Roadmaps: Introduction (posted September 14, 2020)

• Lesson 95 - Guidelines for Architecture Diagrams Revisited (posted August 31, 2020)

• Lesson 94 - Guidelines for Architecture Diagrams (posted August 3, 2020)

• Lesson 93 - What is Software Architecture? (posted July 20, 2020)

• Lesson 92 - Understanding Hybrid Architectures (posted July 6, 2020)

• Lesson 91 - Becoming A Software Architect (Part 6) (posted June 22, 2020)

• Lesson 90 - Becoming A Software Architect (Part 5) (posted June 15, 2020)

• Lesson 89 - Becoming A Software Architect (Part 4) (posted June 8, 2020)

• Lesson 88 - Becoming A Software Architect (Part 3) (posted June 1, 2020)

• Lesson 87 - Becoming A Software Architect (Part 2) (posted May 25, 2020)

• Lesson 86 - Becoming A Software Architect (Part 1) (posted May 18, 2020)

• ✅Lesson 85 - Defining Scalability and Elasticity (posted May 4, 2020)

• Lesson 84 - Defining Deployability (posted April 20, 2020)

• Lesson 83 - Defining Performance and Responsiveness (posted April 6, 2020)

• Lesson 82 - Defining Testability (posted March 23, 2020)

• ✅Lesson 81 - Workflow Event Pattern (posted March 9, 2020)

• ✅Lesson 80 - Choosing the Right Caching Topology(posted February 24, 2020)

• ✅Lesson 79 - Caching Topologies: Near Cache Hybrid(posted February 10, 2020)

• ✅Lesson 78 - Caching Topologies: Replicated Cache(posted January 27, 2020)

• ✅Lesson 77 - Caching Topologies: Distributed Cache (posted January 13, 2020)

• ✅Lesson 76 - Caching Topologies: Single In-Memory Data Grid (posted December 30, 2019)

• Lesson 75 - Microservices Data Services (posted December 16, 2019)

• Lesson 74 - Elephant Migration AntiPattern (posted December 2, 2019)

• Lesson 73 - Architecture Fitness Functions (posted November 18, 2019)

• Lesson 72 - Multi-Broker Pattern (posted November 4, 2019)

• ✅Lesson 71 - Measuring Scalability (posted October 21, 2019)

• ✅Lesson 70 - Preventing Data Loss When Using Messaging (posted October 7, 2019)

• Lesson 69 - The Importance of Event-Driven Architecture (posted September 23, 2019)

• Lesson 68 - Automating Architectural Governance (posted September 9, 2019)

• Lesson 67 - Enterprise Architecture Strategy Case Studies (posted August 26, 2019)

• Lesson 66 - The Durable Interface Strategy of Enterprise Architecture (posted August 12, 2019)

• Lesson 65 - The Distributed Strategy of Enterprise Architecture (posted July 29, 2019)

• Lesson 64 - The Classic Alternatives Strategy of Enterprise Architecture (posted July 15, 2019)

• Lesson 63 - The Prescriptive Strategy of Enterprise Architecture (posted July 1, 2019)

• Lesson 62 - Enterprise Architecture Strategies (posted June 17, 2019)

• Lesson 61 - Extensibility Using Pub/Sub Messaging (posted June 3, 2019)

• Lesson 60 - Microservices and gRPC (posted May 20, 2019)

• ✅Lesson 59 - The Tradeoffs of Loose Coupling (posted May 6, 2019)

• Lesson 58 - Architecture Certification (posted April 22, 2019)

• ✅Lesson 57 - Loose Coupling and the Law of Demeter (posted April 15, 2019)

• Lesson 56 - The Ambulance Pattern (posted April 8, 2019)

• Lesson 55 - Architecture Decision Records (posted April 1, 2019)

• Lesson 54 - The Software Architects Bookshelf (posted March 25, 2019)

• Lesson 53 - Distributed Transactions Using Sagas (posted March 18, 2019)

• Lesson 52 - Modern Approaches to Enterprise Architecture (posted March 11, 2019)

• Lesson 51 - Initiative-Driven Approach to EA (posted March 4, 2019)

• Lesson 50 - Model-Driven Approach to EA (posted February 25, 2019)

• Lesson 49 - What is Enterprise Architecture? (posted February 18, 2019)

• Lesson 48 - Thread Delegate Pattern (posted February 11, 2019)

• Lesson 47 - Channel Monitoring Pattern (posted February 4, 2019)

• Lesson 46 - Reactive Architecture Patterns Introduction (posted January 28, 2019)

• Lesson 45 - Microservices Gateway Pattern (posted January 21, 2019)

• Lesson 44 - Microservices Aggregation Pattern (posted January 14, 2019)

• Lesson 43 - Microservices Orchestration Pattern (posted January 7, 2019)

• Lesson 42 - Deferred Data Migration (posted November 19, 2018)

• Lesson 41 - Microservices Contract Versioning (posted November 12, 2018)

• Lesson 40 - Common Integration Patterns (posted November 5, 2018)

• Lesson 39 - Integration Hubs (ESBs) (posted October 29, 2018)

• Lesson 38 - Identifying Microservices (posted October 22, 2018)

• Lesson 37 - Translating Quality Attributes to Business Concerns (posted October 15, 2018)

• Lesson 36 - Embedded Messaging (posted October 8, 2018)

• Lesson 35 - Watch Notification Pattern (posted October 1, 2018)

• Lesson 34 - Creating Service Domains (posted September 24, 2018)

• Lesson 33 - Creating a Service Taxonomy (posted September 17, 2018)

• Lesson 32 - Diagramming Architecture (posted September 10, 2018)

• Lesson 31 - Presenting Software Architecture (posted August 20, 2018)

• Lesson 30 - Agile and Software Architecture (posted August 13, 2018)

• ✅Lesson 29 - Component and Service Coupling (posted August 6, 2018)

• Lesson 28 - Service Design Patterns (posted July 30, 2018)

• Lesson 27 - Circuit Breaker Pattern (posted July 23, 2018)

• Lesson 26 - Agile Architecture Review Boards (posted July 16, 2018)

• Lesson 25 - Architectural Abstraction (posted July 9, 2018)

• Lesson 24 - Lean Modeling Concepts (posted July 2, 2018)

• Lesson 23 - Orchestration vs. Choreography (posted June 25, 2018)

• Lesson 22 - Integration Architecture: Messaging (posted June 18, 2018)

• Lesson 21 - Integration Architecture: Remote Procedure Invocation (posted June 11, 2018)

• Lesson 20 - Integration Architecture: Shared Database (posted June 4, 2018)

• Lesson 19 - Integration Architecture: File Transfer (posted May 28, 2018)

• Lesson 18 - The Fallacies of Distributed Computing (posted May 21, 2018)

• Lesson 17 - Architecture Tradeoffs (posted May 14, 2018)

• Lesson 16 - The Challenges of Architecture Teams (posted May 7, 2018)

• Lesson 15 - Refactoring: Business Justification (posted April 30, 2018)

• Lesson 14 - Refactoring Patterns: Migration vs. Adaptation (posted April 23, 2018)

• Lesson 13 - Microservices and Reporting (posted April 16, 2018)

• Lesson 12 - CQRS and Microservices (posted April 9, 2018)

• Lesson 11 - Analyzing Architecture: Code Metrics (posted April 2, 2018)

• Lesson 10 - Analyzing Architecture: Microservices (posted Mar 26, 2018)

• Lesson 9 - Analyzing Architecture: Macro Techniques (posted Mar 19, 2018)

• Lesson 8 - Analyzing Architecture: Components (posted Mar 12, 2018)

• Lesson 7 - Analyzing Architecture: Structural Decay (posted Mar 5, 2018)

• Lesson 6 - Classifying Architecture Patterns (posted Feb 26, 2018)

• Lesson 5 - Microservices: Reducing Staging Iterations (posted Feb 19, 2018)

• Lesson 4 - Microservices: Distributed Logging (posted Feb 12, 2018)

• Lesson 3 - Soft Skills: Gaining Technical Breadth (posted Feb 5, 2018)

• Lesson 2 - How Kafka Differs From Standard Messaging (posted Jan 29, 2018)

• Lesson 1 - Event-Driven Architecture: Request/Reply Processing (posted Jan 22, 2018)