Adding content to 116-performance-antipatterns

src/roadmaps/system-design/content/116-performance-antipatterns/100-busy-database.md

@@ -1 +1,8 @@
-# Busy database
+# Busy Database
+
+A busy database in system design refers to a database that is handling a high volume of requests or transactions, this can occur when a system is experiencing high traffic or when a database is not properly optimized for the workload it is handling. This can lead to Performance degradation, Increased resource utilization, Deadlocks and contention, Data inconsistencies. To address a busy database, a number of approaches can be taken such as Scaling out, Optimizing the schema, Caching, and Indexing.
+
+To learn more, visit the following links:
+
+- [Busy Database antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/busy-database/)
+- [Database Design](https://www.sciencedirect.com/topics/computer-science/database-design)

src/roadmaps/system-design/content/116-performance-antipatterns/101-busy-frontend.md

@@ -1 +1,8 @@
-# Busy frontend
+# Busy Frontend
+
+A busy frontend in system design refers to a frontend that is handling a high volume of requests or traffic, this can occur when a system is experiencing high traffic or when a frontend is not properly optimized for the workload it is handling. This can lead to Performance degradation, Increased resource utilization, Increased error rates, and Poor user experience. To address a busy frontend, a number of approaches can be taken such as Scaling out, Optimizing the code, Caching, and Load balancing.
+
+To learn more, visit the following link:
+
+- [Busy Front End antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/busy-front-end/)
+- [What is Front end system design?](https://www.youtube.com/watch?v=XPNMiWyHBAU)

src/roadmaps/system-design/content/116-performance-antipatterns/102-chatty-io.md

@@ -1 +1,8 @@
-# Chatty io
+# Chat IO
+
+Chat IO in system design refers to the design of a chat system, which allows real-time communication between multiple users. A chat system typically consists of the following components: Client, Server, Messaging protocol, Message store, and Notification. To design a chat system, there are several key considerations to keep in mind such as Scalability, Reliability, and Security.
+
+To learn more, visit the following links:
+
+- [Chat Applications System Design](https://javascript.plainenglish.io/chat-applications-system-design-6a070c60c8cd)
+- [Design A Chat System](https://bytebytego.com/courses/system-design-interview/design-a-chat-system)

src/roadmaps/system-design/content/116-performance-antipatterns/103-extraneous-fetching.md

@@ -1 +1,15 @@
-# Extraneous fetching
+# Extraneous Fetching
+
+Extraneous fetching in system design refers to the practice of retrieving more data than is needed for a specific task or operation. This can occur when a system is not optimized for the specific workload or when the system is not properly designed to handle the data requirements.
+
+Extraneous fetching can lead to a number of issues, such as:
+
+- Performance degradation
+- Increased resource utilization
+- Increased network traffic
+- Poor user experience
+
+Visit the following links to learn more:
+
+- [Extraneous Fetching antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/extraneous-fetching/)
+- [What’s the difference between extraneous and confounding variables?](https://www.scribbr.com/frequently-asked-questions/extraneous-vs-confounding-variables/)

src/roadmaps/system-design/content/116-performance-antipatterns/104-improper-instantiation.md

@@ -1 +1,7 @@
-# Improper instantiation
+# Improper Instantiation
+
+Improper instantiation in system design refers to the practice of creating unnecessary instances of an object, class or service, which can lead to performance and scalability issues. This can happen when the system is not properly designed, when the code is not written in an efficient way, or when the code is not optimized for the specific use case.
+
+Learn more from the following links:
+- [Improper Instantiation antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/improper-instantiation/)
+- [What is Instantiation?](https://www.techtarget.com/whatis/definition/instantiation)

src/roadmaps/system-design/content/116-performance-antipatterns/105-monolithic-persistence.md

@@ -1 +1,8 @@
-# Monolithic persistence
+# Monolithic Persistence
+
+Monolithic Persistence in system design refers to the use of a single, monolithic database to store all of the data for an application or system. This approach can be used for simple, small-scale systems but as the system grows and evolves it can become a bottleneck, resulting in poor scalability, limited flexibility, and increased complexity. To address these limitations, a number of approaches can be taken such as Microservices, Sharding, and NoSQL databases.
+
+To learn more, visit the following links:
+
+- [Monolithic Persistence antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/monolithic-persistence/)
+- [System Design: Monoliths and Microservices](https://dev.to/karanpratapsingh/system-design-monoliths-and-microservices-24jn)

src/roadmaps/system-design/content/116-performance-antipatterns/106-no-caching.md

@@ -1 +1,15 @@
-# No caching
+# No Caching
+
+Monolithic persistence in system design refers to the use of a single, monolithic database to store all of the data for an application or system. This approach can be used for simple, small-scale systems, but as the system grows and evolves, it can become a bottleneck, resulting in poor scalability, limited flexibility, and increased complexity.
+
+A monolithic persistence can have several disadvantages:
+
+- Scalability
+- Limited Flexibility
+- Increased Complexity
+- Single Point of Failure
+
+Learn from the following links:
+
+- [What is Caching in system design?](enjoyalgorithms.com/blog/caching-system-design-concept)
+- [No Caching antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/no-caching/)

src/roadmaps/system-design/content/116-performance-antipatterns/107-noisy-neighbor.md

@@ -1 +1,14 @@
-# Noisy neighbor
+# Noisy Neighbor
+
+Noisy neighbor in system design refers to a situation in which one or more components of a system are utilizing a disproportionate amount of shared resources, leading to resource contention and reduced performance for other components. This can occur when a system is not properly designed or configured to handle the workload, or when a component is behaving unexpectedly.
+
+Examples of noisy neighbor scenarios include:
+
+- One user on a shared server utilizing a large amount of CPU or memory, leading to reduced performance for other users on the same server.
+- One process on a shared server utilizing a large amount of I/O, causing other processes to experience slow I/O and increased latency.
+- One application consuming a large amount of network bandwidth, causing other applications to experience reduced throughput.
+
+Learn from the following links:
+
+- [Noisy Neighbor](https://docs.aws.amazon.com/wellarchitected/latest/saas-lens/noisy-neighbor.html)
+- [Get started with Noisy Neighbor antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/noisy-neighbor/noisy-neighbor)

src/roadmaps/system-design/content/116-performance-antipatterns/108-retry-storm.md

@@ -1 +1,8 @@
-# Retry storm
+# Retry Storm
+
+ Retry Storm in system design refers to a situation in which a large number of retries are triggered in a short period of time, leading to a significant increase in traffic and resource usage. This can occur when a system is not properly designed to handle failures or when a component is behaving unexpectedly. This can lead to Performance degradation, Increased resource utilization, Increased network traffic, and Poor user experience. To address retry storms, a number of approaches can be taken such as Exponential backoff, Circuit breaking, and Monitoring and alerting.
+
+To learn more, visit the following links:
+
+- [Retry Storm antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/retry-storm/s)
+- [How To Avoid Retry Storms In Distributed Systems](https://faun.pub/how-to-avoid-retry-storms-in-distributed-systems-91bf34f43c7f)

src/roadmaps/system-design/content/116-performance-antipatterns/109-synchronous-io.md

@@ -1 +1,11 @@
-# Synchronous io
+# Synchronous IO
+
+In system design, synchronous IO refers to a type of input/output (IO) operation where the program execution is blocked or halted until the IO operation completes. This means that the program will wait for the IO operation to finish before it can continue executing the next instruction. Synchronous IO can be used in a variety of scenarios, such as:
+
+- **Reading and writing files:** When a program needs to read or write a file, it can use synchronous IO to ensure that the operation completes before continuing.
+- **Communicating with a database:** When a program needs to query or update a database, it can use synchronous IO to ensure that the operation completes before continuing.
+- **Networking:** When a program needs to send or receive data over a network, it can use synchronous IO to ensure that the operation completes before continuing.
+
+To learn more, visit the following links:
+
+- [What is Synchronous I/O antipattern?](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/synchronous-io/)

src/roadmaps/system-design/content/116-performance-antipatterns/index.md

@@ -1 +1,16 @@
-# Performance antipatterns
+# Performance Antipatterns
+
+what is Performance Antipatterns in system design
+Performance antipatterns in system design refer to common mistakes or suboptimal practices that can lead to poor performance in a system. These patterns can occur at different levels of the system and can be caused by a variety of factors such as poor design, lack of optimization, or lack of understanding of the workload.
+
+Examples of performance antipatterns include:
+
+- **N+1 queries:** This occurs when a system makes multiple queries to a database to retrieve related data, instead of using a single query to retrieve all the necessary data.
+- **Chatty interfaces:** This occurs when a system makes too many small and frequent requests to an external service or API, instead of making fewer, larger requests.
+- **Unbounded data:** This occurs when a system retrieves or processes more data than is necessary for the task at hand, leading to increased resource usage and reduced performance.
+- **Inefficient algorithms:** This occurs when a system uses an algorithm that is not well suited to the task at hand, leading to increased resource usage and reduced performance.
+
+Learn more from the following links:
+
+- [Performance antipatterns for cloud applications](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/)
+- [Guide to Software Performance Antipatterns](http://www.perfeng.com/papers/antipat.pdf)