Merge branch 'iluwatar:master' into master

Author: sanurah

Diff for: .all-contributorsrc

@@ -3484,6 +3484,15 @@
       "contributions": [
         "code"
       ]
+    },
+    {
+      "login": "Suchismita-Deb",
+      "name": "Suchismita Deb",
+      "avatar_url": "https://avatars.githubusercontent.com/u/68535074?v=4",
+      "profile": "https://github.com/Suchismita-Deb",
+      "contributions": [
+        "code"
+      ]
     }
   ],
   "contributorsPerLine": 6,

Diff for: README.md

@@ -6,7 +6,7 @@
 [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=iluwatar_java-design-patterns&metric=coverage)](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns)
 [![Join the chat at https://gitter.im/iluwatar/java-design-patterns](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/iluwatar/java-design-patterns?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-[![All Contributors](https://img.shields.io/badge/all_contributors-382-orange.svg?style=flat-square)](#contributors-)
+[![All Contributors](https://img.shields.io/badge/all_contributors-383-orange.svg?style=flat-square)](#contributors-)
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 
 <br/>
@@ -569,6 +569,7 @@ This project is licensed under the terms of the MIT license.
       <td align="center" valign="top" width="16.66%"><a href="https://github.com/johnklint81"><img src="https://avatars.githubusercontent.com/u/70539458?v=4?s=100" width="100px;" alt="John Klint"/><br /><sub><b>John Klint</b></sub></a><br /><a href="https://github.com/iluwatar/java-design-patterns/commits?author=johnklint81" title="Code">💻</a></td>
       <td align="center" valign="top" width="16.66%"><a href="https://github.com/sanurah"><img src="https://avatars.githubusercontent.com/u/16178588?v=4?s=100" width="100px;" alt="Sanura Hettiarachchi"/><br /><sub><b>Sanura Hettiarachchi</b></sub></a><br /><a href="https://github.com/iluwatar/java-design-patterns/commits?author=sanurah" title="Code">💻</a></td>
       <td align="center" valign="top" width="16.66%"><a href="https://github.com/2897robo"><img src="https://avatars.githubusercontent.com/u/31699375?v=4?s=100" width="100px;" alt="Kim Gi Uk"/><br /><sub><b>Kim Gi Uk</b></sub></a><br /><a href="https://github.com/iluwatar/java-design-patterns/commits?author=2897robo" title="Code">💻</a></td>
+      <td align="center" valign="top" width="16.66%"><a href="https://github.com/Suchismita-Deb"><img src="https://avatars.githubusercontent.com/u/68535074?v=4?s=100" width="100px;" alt="Suchismita Deb"/><br /><sub><b>Suchismita Deb</b></sub></a><br /><a href="https://github.com/iluwatar/java-design-patterns/commits?author=Suchismita-Deb" title="Code">💻</a></td>
     </tr>
   </tbody>
 </table>

Diff for: adapter/README.md

@@ -35,6 +35,10 @@ Wikipedia says
 
 > In software engineering, the adapter pattern is a software design pattern that allows the interface of an existing class to be used as another interface. It is often used to make existing classes work with others without modifying their source code.
 
+Sequence diagram
+
+![Adapter sequence diagram](./etc/adapter-sequence-diagram.png "Adapter sequence diagram")
+
 ## Programmatic Example of Adapter Pattern in Java
 
 The Adapter Pattern example in Java shows how a class with an incompatible interface can be adapted to work with another class.

Diff for: adapter/etc/adapter-sequence-diagram.png

@@ -33,6 +33,10 @@ Microsoft documentation states
 
 > An ambassador service can be thought of as an out-of-process proxy which is co-located with the client. This pattern can be useful for offloading common client connectivity tasks such as monitoring, logging, routing, security (such as TLS), and resiliency patterns in a language agnostic way. It is often used with legacy applications, or other applications that are difficult to modify, in order to extend their networking capabilities. It can also enable a specialized team to implement those features.
 
+Sequence diagram
+
+![Ambassador sequence diagram](./etc/ambassador-sequence-diagram.png "Ambassador sequence diagram")
+
 ## Programmatic Example of Ambassador Pattern in Java
 
 In this example of the Ambassador Pattern in Java, we demonstrate how to implement latency checks, logging, and retry mechanisms to improve system reliability.

Diff for: ambassador/README.md

@@ -44,6 +44,10 @@ In plain words
 
 > Implement a façade or adapter layer between different subsystems that don't share the same semantics. This layer translates requests that one subsystem makes to the other subsystem. Use this pattern to ensure that an application's design is not limited by dependencies on outside subsystems. This pattern was first described by Eric Evans in Domain-Driven Design.
 
+Sequence diagram
+
+![Anti-Corruption Layer sequence diagram](./etc/anti-corruption-layer-sequence-diagram.png "Anti-Corruption Layer sequence diagram")
+
 ## Programmatic Example of Anti-Corruption Layer Pattern in Java
 
 The ACL design pattern in Java provides an intermediary layer that translates data formats, ensuring that integration between different systems does not lead to data corruption.

Diff for: ambassador/etc/ambassador-sequence-diagram.png

@@ -38,6 +38,10 @@ WikiWikiWeb says
 
 > Arrange/Act/Assert is a pattern for arranging and formatting code in UnitTest methods.
 
+Flowchart
+
+![Arrange/Act/Assert flowchart](./etc/arrange-act-assert-flowchart.png "Arrange/Act/Assert flowchart")
+
 ## Programmatic Example of Arrange/Act/Assert Pattern in Java
 
 We need to write comprehensive and clear unit test suite for a class. Using the Arrange/Act/Assert pattern in Java testing ensures clarity.

Diff for: anti-corruption-layer/README.md

@@ -36,6 +36,10 @@ Wikipedia says
 
 > In multithreaded computer programming, asynchronous method invocation (AMI), also known as asynchronous method calls or the asynchronous pattern is a design pattern in which the call site is not blocked while waiting for the called code to finish. Instead, the calling thread is notified when the reply arrives. Polling for a reply is an undesired option.
 
+Sequence diagram
+
+![Async Method Invocation sequence diagram](./etc/async-method-invocation-sequence-diagram.png "Async Method Invocation sequence diagram")
+
 ## Programmatic Example of Async Method Invocation Pattern in Java
 
 Consider a scenario where multiple tasks need to be executed simultaneously. Using the Async Method Invocation pattern, you can initiate these tasks without waiting for each to complete, thus optimizing resource usage and reducing latency.

Diff for: anti-corruption-layer/etc/anti-corruption-layer-sequence-diagram.png

@@ -29,6 +29,10 @@ Wikipedia says
 
 > The balking pattern is a software design pattern that only executes an action on an object when the object is in a particular state. For example, if an object reads ZIP files and a calling method invokes a get method on the object when the ZIP file is not open, the object would "balk" at the request.
 
+Flowchart
+
+![Balking flowchart](./etc/balking-flowchart.png)
+
 ## Programmatic Example of Balking Pattern in Java
 
 This example demonstrates the Balking Pattern in a multithreaded Java application, highlighting state management and concurrency control. The Balking Pattern is exemplified by a washing machine's start button that initiates washing only if the machine is idle. This ensures state management and prevents concurrent issues.

Diff for: arrange-act-assert/README.md

@@ -35,6 +35,10 @@ The Bloc pattern manages the state of an object and allows for dynamically notif
 
 > While not a formalized "Gang of Four" design pattern, Bloc is widely used in state-driven applications. It centralizes state management and propagates state changes to registered observers, following principles of separation of concerns.
 
+### Sequence diagram
+
+![Bloc sequence diagram](./etc/bloc-sequence-diagram.png)
+
 ---
 
 ## Programmatic Example of the Bloc Pattern in Java

Diff for: arrange-act-assert/etc/arrange-act-assert-flowchart.png

@@ -36,6 +36,10 @@ Wikipedia says
 
 > The bridge pattern is a design pattern used in software engineering that is meant to "decouple an abstraction from its implementation so that the two can vary independently"
 
+Sequence diagram
+
+![Bridge sequence diagram](./etc/bridge-sequence-diagram.png)
+
 ## Programmatic Example of Bridge Pattern in Java
 
 Imagine you have a weapon that can have various enchantments, and you need to combine different weapons with different enchantments. How would you handle this? Would you create multiple copies of each weapon, each with a different enchantment, or would you create separate enchantments and apply them to the weapon as needed? The Bridge pattern enables you to do the latter.
@@ -203,10 +207,6 @@ The hammer is unwielded.
 The item's glow fades.
 ```
 
-## Bridge Pattern Class Diagram
-
-![Bridge](./etc/bridge.urm.png "Bridge class diagram")
-
 ## When to Use the Bridge Pattern in Java
 
 Consider using the Bridge pattern when:

Diff for: async-method-invocation/README.md

@@ -40,6 +40,10 @@ public Hero(Profession profession,String name,HairType hairType,HairColor hairCo
 
 As you can see, the number of constructor parameters can quickly become overwhelming, making it difficult to understand their arrangement. Additionally, this list of parameters might continue to grow if you decide to add more options in the future. This is known as the telescoping constructor antipattern.
 
+Sequence diagram
+
+![Builder sequence diagram](./etc/builder-sequence-diagram.png)
+
 ## Programmatic Example of Builder Pattern in Java
 
 In this Java Builder pattern example, we construct different types of `Hero` objects with varying attributes.
@@ -146,10 +150,6 @@ Program output:
 16:28:06.060 [main] INFO com.iluwatar.builder.App -- This is a thief named Desmond with bald head and wielding a bow.
 ```
 
-## Builder Pattern Class Diagram
-
-![Builder](./etc/builder.urm.png "Builder class diagram")
-
 ## When to Use the Builder Pattern in Java
 
 Use the Builder pattern when

Diff for: async-method-invocation/etc/async-method-invocation-sequence-diagram.png

@@ -36,6 +36,10 @@ Wikipedia says
 
 > Business Delegate is a Java EE design pattern. This pattern is directing to reduce the coupling in between business services and the connected presentation tier, and to hide the implementation details of services (including lookup and accessibility of EJB architecture). Business Delegates acts as an adaptor to invoke business objects from the presentation tier.
 
+Sequence diagram
+
+![Business Delegate sequence diagram](./etc/business-delegate-sequence-diagram.png)
+
 ## Programmatic Example of Business Delegate Pattern in Java
 
 The following Java code demonstrates how to implement the Business Delegate pattern. This pattern is particularly useful in applications requiring loose coupling and efficient service interaction.
@@ -145,10 +149,6 @@ Here is the console output.
 21:15:33.794 [main] INFO com.iluwatar.business.delegate.YouTubeService - YouTubeService is now processing
 ```
 
-## Business Delegate Pattern Class Diagram
-
-![Business Delegate](./etc/business-delegate.urm.png "Business Delegate")
-
 ## When to Use the Business Delegate Pattern in Java
 
 Use the Business Delegate pattern when

Diff for: balking/README.md

@@ -31,6 +31,10 @@ In plain words
 
 > An instruction set defines the low-level operations that can be performed. A series of instructions is encoded as a sequence of bytes. A virtual machine executes these instructions one at a time, using a stack for intermediate values. By combining instructions, complex high-level behavior can be defined.
 
+Sequence diagram
+
+![Bytecode sequence diagram](./etc/bytecode-sequence-diagram.png)
+
 ## Programmatic Example of Bytecode Pattern in Java
 
 In this programmatic example, we show how the Bytecode pattern in Java can simplify the execution of complex virtual machine instructions through a well-defined set of operations. This real-world example demonstrates how the Bytecode design pattern in Java can streamline game programming by allowing wizards' behavior to be easily adjusted through bytecode instructions.

Diff for: balking/etc/balking-flowchart.png

@@ -34,6 +34,10 @@ Wikipedia says
 
 > In computing, a cache is a hardware or software component that stores data so that future requests for that data can be served faster; the data stored in a cache might be the result of an earlier computation or a copy of data stored elsewhere. A cache hit occurs when the requested data can be found in a cache, while a cache miss occurs when it cannot. Cache hits are served by reading data from the cache, which is faster than recomputing a result or reading from a slower data store; thus, the more requests that can be served from the cache, the faster the system performs.
 
+Flowchart
+
+![Caching flowchart](./etc/caching-flowchart.png)
+
 ## Programmatic Example of Caching Pattern in Java
 
 In this programmatic example, we demonstrate different Java caching strategies, including write-through, write-around, and write-behind, using a user account management system.

Diff for: bloc/README.md

@@ -37,6 +37,10 @@ Wikipedia says
 
 > In computer programming, a callback, also known as a "call-after" function, is any executable code that is passed as an argument to other code; that other code is expected to call back (execute) the argument at a given time.
 
+Sequence diagram
+
+![Callback sequence diagram](./etc/callback-sequence-diagram.png)
+
 ## Programmatic Example of Callback Pattern in Java
 
 We need to be notified after the executing task has finished. We pass a callback method for the executor and wait for it to call back on us.

Diff for: bloc/etc/bloc-sequence-diagram.png

@@ -35,6 +35,10 @@ Wikipedia says
 
 > In object-oriented design, the chain-of-responsibility pattern is a design pattern consisting of a source of command objects and a series of processing objects. Each processing object contains logic that defines the types of command objects that it can handle; the rest are passed to the next processing object in the chain.
 
+Flowchart
+
+![Chain of Responsibility flowchart](./etc/chain-of-responsibility-flowchart.png)
+
 ## Programmatic Example of Chain of Responsibility Pattern
 
 In this Java example, the Orc King gives orders which are processed by a chain of command representing the Chain of Responsibility pattern. Learn how to implement this design pattern in Java with the following code snippet.
@@ -159,10 +163,6 @@ Orc officer handling request "torture prisoner"
 Orc soldier handling request "collect tax"
 ```
 
-## Chain of Responsibility Pattern Class Diagram
-
-![Chain of Responsibility](./etc/chain-of-responsibility.urm.png "Chain of Responsibility class diagram")
-
 ## When to Use the Chain of Responsibility Pattern in Java
 
 Use Chain of Responsibility when

Diff for: bridge/README.md

@@ -33,6 +33,10 @@ Wikipedia says
 
 > Circuit breaker is a design pattern used in modern software development. It is used to detect failures and encapsulates the logic of preventing a failure from constantly recurring, during maintenance, temporary external system failure or unexpected system difficulties.
 
+Flowchart
+
+![Circuit Breaker flowchart](./etc/circuit-breaker-flowchart.png)
+
 ## Programmatic Example of Circuit Breaker Pattern in Java
 
 This Java example demonstrates how the Circuit Breaker pattern can manage remote service failures and maintain system stability.