Microservice Patterns Quotes

“Although this approach is obscure, it works remarkably well.”
― Chris Richardson, Microservices Patterns: With examples in Java

“Pattern: Transaction log tailing Publish changes made to the database by tailing the transaction log.”
― Chris Richardson, Microservices Patterns: With examples in Java

“Every committed update made by an application is represented as an entry in the database’s transaction log. A transaction log miner can read the transaction log and publish each change as a message to the message broker.”
― Chris Richardson, Microservices Patterns: With examples in Java

“use the more sophisticated and performant approach of tailing the database transaction log.”
― Chris Richardson, Microservices Patterns: With examples in Java

“It’s likely, though, that messaging ordering and scalability are essential.”
― Chris Richardson, Microservices Patterns: With examples in Java

“Fetching multiple resources in a single request is challenging.”
― Chris Richardson, Microservices Patterns: With examples in Java

“Reduced availability. Because the client and service communicate directly without an intermediary to buffer messages, they must both be running for the duration of the exchange.”
― Chris Richardson, Microservices Patterns: With examples in Java

“A REST API should use PUT for updates, but there may be multiple ways to update an order, including cancelling it, revising the order, and so on. Also, an update might not be idempotent, which is a requirement for using PUT.”
― Chris Richardson, Microservices Patterns: With examples in Java

“/orders/order-id-1345?expand=consumer. The query parameter specifies the related resources to return with the Order.”
― Chris Richardson, Microservices Patterns: With examples in Java

“/orders/order-id-1345?expand=consumer. The query parameter specifies the related resources to return”
― Chris Richardson, Microservices Patterns: With examples in Java

“/orders/order-id-1345?expand=consumer”
― Chris Richardson, Microservices Patterns: With examples in Java

“Services should provide default values for missing request attributes. Similarly, clients should ignore any extra response attributes.”
― Chris Richardson, Microservices Patterns: With examples in Java

“The Semantic Versioning specification (Semvers) requires a version number to consist of three parts: MAJOR.MINOR.PATCH”
― Chris Richardson, Microservices Patterns: With examples in Java

“perform a rolling upgrade of your service, so both old and new versions of a service will be running simultaneously.”
― Chris Richardson, Microservices Patterns: With examples in Java

“rolling upgrade”
― Chris Richardson, Microservices Patterns: With examples in Java

“it’s important to precisely define a service’s API using some kind of interface definition language (IDL).”
― Chris Richardson, Microservices Patterns: With examples in Java

“A well-designed interface exposes useful functionality while hiding the implementation.”
― Chris Richardson, Microservices Patterns: With examples in Java

“the concept of API-first design.”
― Chris Richardson, Microservices Patterns: With examples in Java

“There are two patterns for decomposition: Decompose by business capability, which has its origins in business architecture Decompose by subdomain, based on concepts from domain-driven design”
― Chris Richardson, Microservices Patterns: With examples in Java

“Services in a microservice architecture are organized around business concerns—business capabilities or subdomains—rather than technical concerns.”
― Chris Richardson, Microservices Patterns: With examples in Java

“In this case, assigning an operation to a service that needs the information provided by the operation is a better choice. In other situations, it might make sense to assign an operation to the service that has the information necessary to handle it.”
― Chris Richardson, Microservices Patterns: With examples in Java

“It won’t be able to create an order if any of those other services are unavailable”
― Chris Richardson, Microservices Patterns: With examples in Java

“Sometimes, you can reduce the latency to an acceptable amount by implementing a batch API for fetching multiple objects in a single round trip. But in other situations, the solution is to combine services, replacing expensive IPC with language-level method or function calls.”
― Chris Richardson, Microservices Patterns: With examples in Java

“Network latency is an ever-present concern in a distributed system.”
― Chris Richardson, Microservices Patterns: With examples in Java

“Ideally, a change will only affect a single team and a single service. CCP is the antidote to the distributed monolith anti-pattern.”
― Chris Richardson, Microservices Patterns: With examples in Java

“Common Closure Principle: The classes in a package should be closed together against the same kinds of changes. A change that affects a package affects all the classes in that package. Robert C. Martin”
― Chris Richardson, Microservices Patterns: With examples in Java

“Decompose by subdomain and Decompose by business capability are the two main patterns for defining an application’s microservice architecture.”
― Chris Richardson, Microservices Patterns: With examples in Java

“The DDD concept of subdomains and bounded contexts maps nicely to services within a microservice architecture. Also, the microservice architecture’s concept of autonomous teams owning services is completely aligned with the DDD’s concept of each domain model being owned and developed by a single team. Even better, as I describe later in this section, the concept of a subdomain with its own domain model is a great way to eliminate god classes and thereby make decomposition easier.”
― Chris Richardson, Microservices Patterns: With examples in Java

“Subdomains are identified using the same approach as identifying business capabilities: analyze the business and identify the different areas of expertise. The end result is very likely to be subdomains that are similar to the business capabilities.”
― Chris Richardson, Microservices Patterns: With examples in Java

“DDD is quite different than the traditional approach to enterprise modeling, which creates a single model for the entire enterprise. In such a model there would be, for example, a single definition of each business entity, such as customer, order, and so on. The problem with this kind of modeling is that getting different parts of an organization to agree on a single model is a monumental task. Also, it means that from the perspective of a given part of the organization, the model is overly complex for their needs. Moreover, the domain model can be confusing because different parts of the organization might use either the same term for different concepts or different terms for the same concept. DDD avoids these problems by defining multiple domain models, each with an explicit scope.”
― Chris Richardson, Microservices Patterns: With examples in Java