When communicating between services in a microservices architecture, you have three basic protocols to choose from: REST via an API Gateway, request/reply messaging, and gRPC. In this lesson I talk about each of these communication protocols and discuss the trade-offs associated with each. Stamp Coupling: https://www.developertoarchitect.com/lessons/lesson105.html Software Architecture Monday: https://bit.ly/3dadEe3 Head First Software Architecture: https://amzn.to/3VNFI0o Fundamentals of Software Architecture: https://amzn.to/3rgFLjY Software Architecture: The Hard Parts:  ..read more

Out of the hundreds of architectural characteristics out there, how do you know which ones are important to your particular system? Is scalability critical? How about responsiveness, or availability, or even testability? In this lesson I discuss various techniques for identifying which architectural characteristics are important to your system, and how to communicate those to your product team and business stakeholders. Software Architecture Monday: https://bit.ly/3dadEe3 Fundamentals of Software Architecture: https://amzn.to/3rgFLjY Software Architecture: The Hard Parts: https ..read more

In this milestone lesson, I talk about the story behind Software Architecture Monday, and show examples of others I know who have done similar giveback through blogs, articles, newsletters, and videos. I then issue a call to action for all of my listeners, encouraging you to do the same. This is an important milestone, and an important message. https://jacquiread.com/ https://www.youtube.com/@ContinuousDeliveryhttps://www.linkedin.com/in/karolskrzymowski/ https://www.youtube.com/@BridgingTheGap-eu-com https://www.linkedin.com/in/davitshergilashvili/ Software Architecture Monday: https ..read more

In the prior lesson (lesson 198) I discussed an anti-pattern associated with the number of derived events to trigger from a service. In this lesson I revisit the topic of derived events in event-driven architecture, but this time with regard to the payload of the event, and specifically how to avoid anemic events. An anemic event is one that doesn’t contain enough information to process the event. But how much information is not enough? How much information is too much? In this lesson I talk about the trade-offs associated with key-based events and full-data events, and then show how to avoid ..read more

Knowing how many derived events to trigger from an event processor in event-driven architecture can sometimes be challenging, leading to what is known as the Swarm of Gnats anti-pattern.  Gnats are very small, annoying flying insects that buzz around your head, bothering you enough to go back indoors on a beautiful sunny day. The Swarm of Gnats anti-pattern describes the situation where an event processor triggers too many fine-grained, detailed derived events, just like those annoying gnats you want to just swipe away. This practice can saturate and overwhelm a system, eventually leadin ..read more

Developers and software architects must have keen technology skills to do their job. However, to be effective in their job they also must have keen communication skills. And that’s exactly what the book Communication Patterns by Jacqui Read teaches you. In this lesson I talk about Jacqui’s book, how it is structured, and also show some of the many communication patterns from the book that can make you a more effective developer and software architect. Jacqui Read: https://jacquiread.com/ Communication Patterns Book: https://www.amazon.com/dp/1098140540/ Software Architecture Monday: http ..read more

Architectural modularity is the breaking up (or organizing) of systems in to separate parts, whereas granularity is about the size of those parts. Modularity provides better maintainability, testability, deployability, reliability, fault tolerance, and scalability in our systems; the more modular the architecture is, the better these characteristics are. In this lesson I walk through various architectural styles and demonstrate how each style supports architectural modularity.  Software Architecture Monday: https://bit.ly/3dadEe3 Head First Software Architecture: https://amzn.t ..read more

Sacrificial architecture is a practice described in an article by Martin Fowler about scrapping an entire architecture (or only parts of it) and rebuilding it from scratch. In this lesson I talk about this concept and show examples of different forms of sacrificial architecture using the microkernel, layered, and microservices architectural styles.  Article: https://event-driven.io/en/removability_over_maintainability/ Article: https://martinfowler.com/bliki/SacrificialArchitecture.html Software Architecture Monday: https://bit.ly/3dadEe3 Head First Software Architecture: https ..read more

In Lesson 190 I talked about the difference between a logical and physical architecture. In this lesson I demonstrate a technique for identifying initial core logical components called the Actor/Action approach. With this approach, you identify the actors in the system, identify the major actions each actor performs in the system, and from those actions identify the initial core logical components of the system.   Lesson 190: https://www.developertoarchitect.com/lessons/lesson190.html Software Architecture Monday: https://bit.ly/3dadEe3 Head First Software Architectur ..read more

In Lesson 190 I talked about the difference between a logical and physical architecture. In this lesson I demonstrate a technique for identifying initial core logical components called the Workflow approach. The workflow approach is useful when you have basic knowledge of the major paths a user might take though the system, allowing you to identify key actions, and from those actions identify the initial core logical components of the system.   Lesson 190: https://www.developertoarchitect.com/lessons/lesson190.html Software Architecture Monday: https://bit.ly/3dadEe3 ..read more