docs: update Command documentation

command/README.md

@@ -8,14 +8,16 @@ tag:
 
 ## Also known as
 
-Action, Transaction
+* Action
+* Transaction
 
 ## Intent
 
-Encapsulate a request as an object, thereby letting you parameterize clients with different
+The Command design pattern encapsulates a request as an object, thereby allowing for parameterization of clients with
-requests, queue or log requests, and support undoable operations.
+queues, requests, and operations. It also allows for the support of undoable operations.
 
 ## Explanation
+
 Real-world example
 
 > There is a wizard casting spells on a goblin. The spells are executed on the goblin one by one.
@@ -37,13 +39,15 @@ Wikipedia says
 Here's the sample code with wizard and goblin. Let's start from the `Wizard` class.
 
 ```java
+
 @Slf4j
 public class Wizard {
 
     private final Deque<Runnable> undoStack = new LinkedList<>();
     private final Deque<Runnable> redoStack = new LinkedList<>();
 
-  public Wizard() {}
+    public Wizard() {
+    }
 
     public void castSpell(Runnable runnable) {
         runnable.run();
@@ -76,6 +80,7 @@ public class Wizard {
 Next, we have the goblin who's the target of the spells.
 
 ```java
+
 @Slf4j
 public abstract class Target {
 
@@ -223,14 +228,40 @@ system with new transactions.
 
 ## Known uses
 
+* GUI Buttons and menu items in desktop applications.
+* Operations in database systems and transactional systems that support rollback.
+* Macro recording in applications like text editors and spreadsheets.
 * [java.lang.Runnable](http://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)
 * [org.junit.runners.model.Statement](https://github.com/junit-team/junit4/blob/master/src/main/java/org/junit/runners/model/Statement.java)
 * [Netflix Hystrix](https://github.com/Netflix/Hystrix/wiki)
 * [javax.swing.Action](http://docs.oracle.com/javase/8/docs/api/javax/swing/Action.html)
 
+## Consequences
+
+Benefits:
+
+* Decouples the object that invokes the operation from the one that knows how to perform it.
+* It's easy to add new Commands, because you don't have to change existing classes.
+* You can assemble a set of commands into a composite command.
+
+Trade-offs:
+
+* Increases the number of classes for each individual command.
+* Can complicate the design by adding multiple layers between senders and receivers.
+
+## Related Patterns
+
+* [Composite](https://java-design-patterns.com/patterns/composite/): Commands can be composed using the Composite
+  pattern
+  to create macro commands.
+* [Memento](https://java-design-patterns.com/patterns/memento/): Can be used for implementing undo mechanisms.
+* [Observer](https://java-design-patterns.com/patterns/observer/): The pattern can be observed for changes that trigger
+  commands.
+
 ## Credits
 
 * [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
 * [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
 * [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7)
 * [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=f27d2644fbe5026ea448791a8ad09c94)
+* [Pattern-Oriented Software Architecture, Volume 1: A System of Patterns](https://amzn.to/3PFUqSY)