From 6299deb8de602459d0309b73a0a2acdec90ba020 Mon Sep 17 00:00:00 2001 From: syedmouaazfarrukh Date: Wed, 18 Jan 2023 08:22:22 -0800 Subject: [PATCH] Adding content to 116-performance-antipatterns --- .../100-busy-database.md | 9 ++++++++- .../101-busy-frontend.md | 9 ++++++++- .../102-chatty-io.md | 9 ++++++++- .../103-extraneous-fetching.md | 16 +++++++++++++++- .../104-improper-instantiation.md | 8 +++++++- .../105-monolithic-persistence.md | 9 ++++++++- .../106-no-caching.md | 16 +++++++++++++++- .../107-noisy-neighbor.md | 15 ++++++++++++++- .../108-retry-storm.md | 9 ++++++++- .../109-synchronous-io.md | 12 +++++++++++- .../116-performance-antipatterns/index.md | 17 ++++++++++++++++- 11 files changed, 118 insertions(+), 11 deletions(-) diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/100-busy-database.md b/src/roadmaps/system-design/content/116-performance-antipatterns/100-busy-database.md index 5f308313b..9117f6e35 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/100-busy-database.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/100-busy-database.md @@ -1 +1,8 @@ -# Busy database \ No newline at end of file +# 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) \ No newline at end of file diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/101-busy-frontend.md b/src/roadmaps/system-design/content/116-performance-antipatterns/101-busy-frontend.md index 7b21e7646..e7303a4c4 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/101-busy-frontend.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/101-busy-frontend.md @@ -1 +1,8 @@ -# Busy frontend \ No newline at end of file +# 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) \ No newline at end of file diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/102-chatty-io.md b/src/roadmaps/system-design/content/116-performance-antipatterns/102-chatty-io.md index b57cd5513..6492afeb0 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/102-chatty-io.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/102-chatty-io.md @@ -1 +1,8 @@ -# Chatty io \ No newline at end of file +# 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) \ No newline at end of file diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/103-extraneous-fetching.md b/src/roadmaps/system-design/content/116-performance-antipatterns/103-extraneous-fetching.md index b5a513626..0b5af4656 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/103-extraneous-fetching.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/103-extraneous-fetching.md @@ -1 +1,15 @@ -# Extraneous fetching \ No newline at end of file +# 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/) \ No newline at end of file diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/104-improper-instantiation.md b/src/roadmaps/system-design/content/116-performance-antipatterns/104-improper-instantiation.md index f2daa5409..9346afe4f 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/104-improper-instantiation.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/104-improper-instantiation.md @@ -1 +1,7 @@ -# Improper instantiation \ No newline at end of file +# 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) \ No newline at end of file diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/105-monolithic-persistence.md b/src/roadmaps/system-design/content/116-performance-antipatterns/105-monolithic-persistence.md index 64dfb0df3..b4d767e06 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/105-monolithic-persistence.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/105-monolithic-persistence.md @@ -1 +1,8 @@ -# Monolithic persistence \ No newline at end of file +# 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) \ No newline at end of file diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/106-no-caching.md b/src/roadmaps/system-design/content/116-performance-antipatterns/106-no-caching.md index d011521d1..23ddfed7f 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/106-no-caching.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/106-no-caching.md @@ -1 +1,15 @@ -# No caching \ No newline at end of file +# 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/) \ No newline at end of file diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/107-noisy-neighbor.md b/src/roadmaps/system-design/content/116-performance-antipatterns/107-noisy-neighbor.md index 0d6f984d5..ccb32e6ca 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/107-noisy-neighbor.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/107-noisy-neighbor.md @@ -1 +1,14 @@ -# Noisy neighbor \ No newline at end of file +# 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) \ No newline at end of file diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/108-retry-storm.md b/src/roadmaps/system-design/content/116-performance-antipatterns/108-retry-storm.md index 7665b25d0..573b562b0 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/108-retry-storm.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/108-retry-storm.md @@ -1 +1,8 @@ -# Retry storm \ No newline at end of file +# 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) \ No newline at end of file diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/109-synchronous-io.md b/src/roadmaps/system-design/content/116-performance-antipatterns/109-synchronous-io.md index 6ef680246..251392fe0 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/109-synchronous-io.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/109-synchronous-io.md @@ -1 +1,11 @@ -# Synchronous io \ No newline at end of file +# 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/) \ No newline at end of file diff --git a/src/roadmaps/system-design/content/116-performance-antipatterns/index.md b/src/roadmaps/system-design/content/116-performance-antipatterns/index.md index c03eba612..fc7a374c0 100644 --- a/src/roadmaps/system-design/content/116-performance-antipatterns/index.md +++ b/src/roadmaps/system-design/content/116-performance-antipatterns/index.md @@ -1 +1,16 @@ -# Performance antipatterns \ No newline at end of file +# 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) \ No newline at end of file