docs: Content SEO updates (#2990)

* update yaml frontmatter format

* update abstract document

* update abstract factory

* use the new pattern template

* acyclic visitor seo

* adapter seo

* ambassador seo

* acl seo

* aaa seo

* async method invocation seo

* balking seo

* bridge seo

* builder seo

* business delegate and bytecode seo

* caching seo

* callback seo

* chain seo

* update headings

* circuit breaker seo

* client session + collecting parameter seo

* collection pipeline seo

* combinator SEO

* command seo

* cqrs seo

* commander seo

* component seo

* composite seo

* composite entity seo

* composite view seo

* context object seo

* converter seo

* crtp seo

* currying seo

* dao seo

* data bus seo

* data locality seo

* data mapper seo

* dto seo

* decorator seo

* delegation seo

* di seo

* dirty flag seo

* domain model seo

* double buffer seo

* double checked locking seo

* double dispatch seo

* dynamic proxy seo

* event aggregator seo

* event-based asynchronous seo

* eda seo

* event queue seo

* event sourcing seo

* execute around seo

* extension objects seo

* facade seo

* factory seo

* factory kit seo

* factory method seo

* fanout/fanin seo

* feature toggle seo

* filterer seo

* fluent interface seo

* flux seo

* flyweight seo

* front controller seo

* function composition seo

* game loop seo

* gateway seo

* guarded suspension seo

* half-sync/half-async seo

* health check seo

* hexagonal seo

* identity map seo

* intercepting filter seo

* interpreter seo

* iterator seo

* layers seo

* lazy loading seo

* leader election seo

* leader/followers seo

* lockable object seo

* rename and add seo for marker interface

* master-worker seo

* mediator seo

* memento seo

* metadata mapping seo

* microservice aggregator seo

* api gw seo

* microservices log aggregration seo

* mvc seo

* mvi seo

* mvp seo

* mvvm seo

* monad seo

* monitor seo

* monostate seo

* multiton seo

* mute idiom seo

* naked objects & notification seo

* null object seo

* object mother seo

* object pool seo

* observer seo

* optimistic locking seo

* page controller seo

* page object seo

* parameter object seo

* partial response seo

* pipeline seo

* poison pill seo

* presentation model seo

* private class data seo

* producer-consumer seo

* promise seo

* property seo

* prototype seo

* proxy seo

* queue-based load leveling seo

* reactor seo

* registry seo

* repository seo

* RAII seo

* retry seo

* role object seo

* saga seo

* separated interface seo

* serialized entity seo

* serialized lob seo

* servant seo

* server session seo

* service layer seo

* service locator seo

* service to worker seo

* sharding seo

* single table inheritance seo

* singleton seo

* spatial partition seo

* special case seo

* specification seo

* state seo

* step builder seo

* strangler seo

* strategy seo

* subclass sandbox seo

* table module seo

* template method seo

* throttling seo

* tolerant reader seo

* trampoline seo

* transaction script seo

* twin seo

* type object seo

* unit of work seo

* update method seo

* value object seo

* version number seo

* virtual proxy seo

* visitor seo

* seo enhancements

* seo improvements

* SEO enhancements

* SEO improvements

* SEO additions

* SEO improvements

* more SEO improvements

* rename hexagonal + SEO improvements

* SEO improvements

* more SEO stuff

* SEO improvements

* SEO optimizations

* SEO enhancements

* enchance SEO

* improve SEO

* SEO improvements

* update headers

command-query-responsibility-segregation/README.md

@@ -1,22 +1,24 @@
 ---
-title: Command Query Responsibility Segregation
+title: "Command Query Responsibility Segregation in Java: Optimizing Data Interaction for Scalability"
+shortTitle: Command Query Responsibility Segregation (CQRS)
+description: "Learn about the Command Query Responsibility Segregation (CQRS) pattern in Java. Discover how segregating commands and queries can enhance the scalability, performance, and maintainability of your software systems."
 category: Architectural
 language: en
 tag:
-    - Event-driven
-    - Performance
-    - Scalability
+  - Event-driven
+  - Performance
+  - Scalability
 ---
 
 ## Also known as
 
 * CQRS
 
-## Intent
+## Intent of Command Query Responsibility Segregation Design Pattern
 
-Command Query Responsibility Segregation aims to segregate the operations that modify the state of an application (commands) from the operations that read the state (queries).
+Command Query Responsibility Segregation (CQRS) aims to segregate the operations that modify the state of an application (commands) from the operations that read the state (queries). This separation enhances scalability, performance, and maintainability in complex software systems.
 
-## Explanation
+## Detailed Explanation of Command Query Responsibility Segregation Pattern with Real-World Examples
 
 Real-world example
 
@@ -24,13 +26,13 @@ Real-world example
 
 In plain words
 
-> The CQRS design pattern separates the actions of modifying data (commands) from the actions of retrieving data (queries) to enhance performance, scalability, and maintainability in software systems.
+> The CQRS design pattern separates the actions of modifying data (commands) from the actions of retrieving data (queries) to enhance performance, scalability, and maintainability in software systems. By implementing CQRS, you can optimize your system's read and write operations independently, allowing for more efficient data handling and improved overall system performance.
 
 Microsoft's documentation says
 
 > CQRS separates reads and writes into different models, using commands to update data, and queries to read data.
 
-**Programmatic Example**
+## Programmatic Example of CQRS Pattern in Java
 
 One way to implement the Command Query Responsibility Segregation (CQRS) pattern is to separate the read and write operations into different services.
 
@@ -93,19 +95,19 @@ Program output:
 17:37:56.042 [main] INFO  com.iluwatar.cqrs.app.App - jBloch books : [Book(title=Effective Java, price=40.54), Book(title=Java Puzzlers, price=39.99), Book(title=Java Concurrency in Practice, price=29.4)]
 ```
 
-## Applicability
+## When to Use the Command Query Responsibility Segregation Pattern in Java
 
-* Systems requiring distinct models for read and write operations for scalability and maintainability.
-* Complex domain models where the task of updating objects differs significantly from the task of reading object data.
-* Scenarios where performance optimization for read operations is crucial, and the system can benefit from different data models or databases for reads and writes.
+* Systems requiring distinct models for read and write operations for scalability and maintainability, such as e-commerce platforms and high-traffic websites.
+* Complex domain models, like financial services or healthcare applications, where the task of updating objects differs significantly from the task of reading object data.
+* Scenarios where performance optimization for read operations is crucial, and the system can benefit from different data models or databases for reads and writes, enhancing data retrieval speed and accuracy.
 
-## Known Uses
+## Real-World Applications of CQRS Pattern in Java
 
 * Distributed Systems and Microservices Architecture, where different services manage read and write responsibilities.
 * Event-Sourced Systems, where changes to the application state are stored as a sequence of events.
 * High-Performance Web Applications, segregating read and write databases to optimize load handling.
 
-## Consequences
+## Benefits and Trade-offs of Command Query Responsibility Segregation Pattern
 
 Benefits:
 
@@ -120,13 +122,13 @@ Trade-Offs:
 * Overhead: Might be an overkill for simple systems where the benefits do not outweigh the additional complexity.
 * Learning Curve: Requires a deeper understanding and careful design to implement effectively, increasing the initial learning curve.
 
-## Related Patterns
+## Related Java Design Patterns
 
 * [Event Sourcing](https://java-design-patterns.com/patterns/event-sourcing/): Often used in conjunction with CQRS, where changes to the application state are stored as a sequence of events.
 * Domain-Driven Design (DDD): CQRS fits well within the DDD context, providing clear boundaries and separation of concerns.
 * [Repository](https://java-design-patterns.com/patterns/repository/): Can be used to abstract the data layer, providing a more seamless integration between the command and query sides.
 
-## Credits
+## References and Credits
 
 * [Implementing Domain-Driven Design](https://amzn.to/3TJN2HH)
 * [Microsoft .NET: Architecting Applications for the Enterprise](https://amzn.to/4aktRes)