If you’ve been wondering what the Zachman framework is all about and how it works, then you’ve come to the right place. The Zachman Enterprise Framework provides a useful way of modeling the enterprise (or even a department or division) within an organization. Even though John Zachman from IBM created the first version of the framework in 1992, it is still in wide use today. In this lesson I briefly describe how the Zachman framework is structured and what the various models mean and what is typically included in each.  Reference Links: Software Architecture Monday: https://bit ..read more

The infinity architecture anti-pattern can take on many forms. In this lesson I define what the infinity architecture anti-pattern is and show some real-world examples of this all-to-common anti-pattern, and also ways to avoid it. Then I show another form of this anti-pattern involving contracts between services or components.  Reference Links: Software Architecture Monday: https://bit.ly/3dadEe3 Fundamentals of Software Architecture: https://amzn.to/3rgFLjY Software Architecture: The Hard Parts: https://amzn.to/3BjMMF2 Back To Lessons    ..read more

A viewer of Software Architecture Monday posted a question last month asking whether modern system integration should still use an ESB (Enterprise Service Bus) to integrate both legacy and modern applications. I thought it was such a great and pertinent question that I decided to do a lesson on answering this question. In this lesson I revisit the role of an ESB and answer the question whether it is still a relevant and effective technique in today's modern world for systems integration.  Reference Links: Software Architecture Monday: https://bit.ly/3dadEe3 Fundamentals of Software ..read more

There’s a lot of confusion about the difference between Service-Based Architecture and Service-Oriented Architecture (SOA). Naming things is hard, and unfortunately the names of these two architecture styles don’t describe the differences between them. In this lesson Mark Richards talks about each of these architecture styles and illustrates the differences between them. As you’ll learn in this lesson, comparing these two architecture styles is like comparing apples to oranges—they are both very much different.  Reference Links: Software Architecture Monday: https://bit.ly/3dadEe3 F ..read more

How does a Solution Architect differ from an Application Architect? What’s the difference between an Enterprise Architect and a Domain Architect? What exactly does a Cloud Architect do? With so many software architecture roles and titles out there, it's hard to know what the differences are between these titles and what the actual role is. While it would take literally days to describe each role and title, Mark Richards summarizes these titles in this short lesson and provides a classification taxonomy to better understand each of these roles and how they relate to each other.   Ref ..read more

You can use architecture fitness functions (described in Lesson 73) to perform some sort of objective integrity assessment of some sort of architecture characteristic. A good example of this is in Lesson 71 - Measuring Scalability. The use of observability and metrics is an example of "quantitative analysis". But what if metrics don’t exist yet or you are building a new system? That’s where "qualitative analysis" comes in. In this lesson Mark Richards shows the differences between quantitative analysis and qualitative analysis and how to use each within architecture to make better decisions ..read more

In lesson 147 Mark Richards talked about the fallacies of versioning, which he and Neal Ford coined as the 9th fallacy of distributed computing. In this lesson he discusses the 10th fallacy of distributed computing he and Neal coined—"compensating updates always work". Compensating updates can fail just like any other transaction, and also produce some bad side effects. Mark shows you how these side effects and failures can occur, leaving you in quite a bad state data-wise.   Reference Links: Software Architecture Monday: https://bit.ly/3dadEe3 Fundamentals of Software Architecture ..read more

In lesson 111 Mark Richards talked about CAP Theorem and illustrated what it meant. He also talked about in-memory replicated caching in lesson 78 and distributed caching in lesson 77. In this lesson Mark will talk about the combination of these lessons, and how CAP Theorem comes into play when using caching. He’ll show the CAP options you have with in-memory replicated caching and distributed caching, but also show some complications involving CAP Theorem when it comes to distributed caching.     Reference Links: Lesson 111 - CAP Theorem Illustrated: https://www.developertoarc ..read more

A fallacy is something that we believe to be true, but it’s not. In Lesson 18 Mark Richards talked about the 8 fallacies of distributed computing. In this lesson Mark talks about the challenges of versioning within a microservices ecosystem, something he coined as the 9th fallacy of distributed computing—"versioning is simple".  Reference Links: Software Architecture Monday: https://bit.ly/3dadEe3 Fundamentals of Software Architecture: https://amzn.to/3rgFLjY Software Architecture: The Hard Parts: https://amzn.to/3BjMMF2 Back To Lessons      N ..read more

When analyzing architecture trade-offs is is common to create a scorecard to help make a particular decision. However, this can lead to an anti-pattern—something that seems like a good idea at the time but can lead you down a bad path. In this lesson Mark Richards shows you what he calls the “out-of-context” scorecard anti-pattern and how to avoid this trap when analyzing tradeoffs using scorecards.   Reference Links: Software Architecture Monday: https://bit.ly/3dadEe3 Fundamentals of Software Architecture: https://amzn.to/3rgFLjY Software Architecture: The Hard Parts: ht ..read more