diff --git a/src/data/roadmaps/system-design/content/ambassador@Hja4YF3JcgM6CPwB1mxmo.md b/src/data/roadmaps/system-design/content/ambassador@Hja4YF3JcgM6CPwB1mxmo.md index d95900977..fd7c30040 100644 --- a/src/data/roadmaps/system-design/content/ambassador@Hja4YF3JcgM6CPwB1mxmo.md +++ b/src/data/roadmaps/system-design/content/ambassador@Hja4YF3JcgM6CPwB1mxmo.md @@ -4,6 +4,6 @@ Create helper services that send network requests on behalf of a consumer servic 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. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Ambassador pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/ambassador) +- [@article@Ambassador pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/ambassador) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/anti-corruption-layer@4hi7LvjLcv8eR6m-uk8XQ.md b/src/data/roadmaps/system-design/content/anti-corruption-layer@4hi7LvjLcv8eR6m-uk8XQ.md index 2f1e65a0b..2b96ed18f 100644 --- a/src/data/roadmaps/system-design/content/anti-corruption-layer@4hi7LvjLcv8eR6m-uk8XQ.md +++ b/src/data/roadmaps/system-design/content/anti-corruption-layer@4hi7LvjLcv8eR6m-uk8XQ.md @@ -2,6 +2,6 @@ Implement a facade 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. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Anti-corruption Layer pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/anti-corruption-layer) +- [@article@Anti-corruption Layer pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/anti-corruption-layer) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/application-caching@5Ux_JBDOkflCaIm4tVBgO.md b/src/data/roadmaps/system-design/content/application-caching@5Ux_JBDOkflCaIm4tVBgO.md index 44aa440af..78eeeb1ba 100644 --- a/src/data/roadmaps/system-design/content/application-caching@5Ux_JBDOkflCaIm4tVBgO.md +++ b/src/data/roadmaps/system-design/content/application-caching@5Ux_JBDOkflCaIm4tVBgO.md @@ -1,14 +1,14 @@ # Application Caching -In-memory caches such as Memcached and Redis are key-value stores between your application and your data storage. Since the data is held in RAM, it is much faster than typical databases where data is stored on disk. RAM is more limited than disk, so [cache invalidation](https://en.wikipedia.org/wiki/Cache_algorithms) algorithms such as [least recently used (LRU)]() can help invalidate 'cold' entries and keep 'hot' data in RAM. +In-memory caches such as Memcached and Redis are key-value stores between your application and your data storage. Since the data is held in RAM, it is much faster than typical databases where data is stored on disk. RAM is more limited than disk, so [cache invalidation](https://en.wikipedia.org/wiki/Cache_algorithms) algorithms such as [least recently used (LRU)](https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_\(LRU\)) can help invalidate 'cold' entries and keep 'hot' data in RAM. Redis has the following additional features: -- Persistence option -- Built-in data structures such as sorted sets and lists +* Persistence option +* Built-in data structures such as sorted sets and lists Generally, you should try to avoid file-based caching, as it makes cloning and auto-scaling more difficult. -Visit the following links to learn more: +Visit the following resources to learn more: -- [@opensource@Intro to Application Caching](https://github.com/donnemartin/system-design-primer#application-caching) +- [@opensource@Intro to Application Caching](https://github.com/donnemartin/system-design-primer#application-caching) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/application-layer@XXuzTrP5UNVwSpAk-tAGr.md b/src/data/roadmaps/system-design/content/application-layer@XXuzTrP5UNVwSpAk-tAGr.md index 8e3ad1f67..b7c954844 100644 --- a/src/data/roadmaps/system-design/content/application-layer@XXuzTrP5UNVwSpAk-tAGr.md +++ b/src/data/roadmaps/system-design/content/application-layer@XXuzTrP5UNVwSpAk-tAGr.md @@ -4,11 +4,12 @@ Separating out the web layer from the application layer (also known as platform ![](https://i.imgur.com/F0cjurv.png) -## Disadvantages +Disadvantages +------------- -- Adding an application layer with loosely coupled services requires a different approach from an architectural, operations, and process viewpoint (vs a monolithic system). -- Microservices can add complexity in terms of deployments and operations. +* Adding an application layer with loosely coupled services requires a different approach from an architectural, operations, and process viewpoint (vs a monolithic system). +* Microservices can add complexity in terms of deployments and operations. -For more resources, visit the following links: +Visit the following resources to learn more: -- [@article@Intro to architecting systems for scale](http://lethain.com/introduction-to-architecting-systems-for-scale/#platform_layer) +- [@article@Intro to architecting systems for scale](http://lethain.com/introduction-to-architecting-systems-for-scale/#platform_layer) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/async-request-reply@eNFNXPsFiryVxFe4unVxk.md b/src/data/roadmaps/system-design/content/async-request-reply@eNFNXPsFiryVxFe4unVxk.md index 5abdfc39d..5da76a9eb 100644 --- a/src/data/roadmaps/system-design/content/async-request-reply@eNFNXPsFiryVxFe4unVxk.md +++ b/src/data/roadmaps/system-design/content/async-request-reply@eNFNXPsFiryVxFe4unVxk.md @@ -2,6 +2,6 @@ Decouple backend processing from a frontend host, where backend processing needs to be asynchronous, but the frontend still needs a clear response. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Asynchronous Request-Reply pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/async-request-reply) +- [@article@Asynchronous Request-Reply pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/async-request-reply) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/asynchronism@84N4XY31PwXRntXX1sdCU.md b/src/data/roadmaps/system-design/content/asynchronism@84N4XY31PwXRntXX1sdCU.md index 5cc66e0b2..ba0eb5b25 100644 --- a/src/data/roadmaps/system-design/content/asynchronism@84N4XY31PwXRntXX1sdCU.md +++ b/src/data/roadmaps/system-design/content/asynchronism@84N4XY31PwXRntXX1sdCU.md @@ -2,10 +2,10 @@ Asynchronous workflows help reduce request times for expensive operations that would otherwise be performed in-line. They can also help by doing time-consuming work in advance, such as periodic aggregation of data. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Patterns for microservices - Sync vs Async](https://medium.com/inspiredbrilliance/patterns-for-microservices-e57a2d71ff9e) -- [@video@It's all a numbers game](https://www.youtube.com/watch?v=1KRYH75wgy4) - [@article@Applying back pressure when overloaded](http://mechanical-sympathy.blogspot.com/2012/05/apply-back-pressure-when-overloaded.html) - [@article@Little's law](https://en.wikipedia.org/wiki/Little%27s_law) - [@article@What is the difference between a message queue and a task queue?](https://www.quora.com/What-is-the-difference-between-a-message-queue-and-a-task-queue-Why-would-a-task-queue-require-a-message-broker-like-RabbitMQ-Redis-Celery-or-IronMQ-to-function) +- [@video@It's all a numbers game](https://www.youtube.com/watch?v=1KRYH75wgy4) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/availability-in-numbers@uHdrZllrZFAnVkwIB3y5-.md b/src/data/roadmaps/system-design/content/availability-in-numbers@uHdrZllrZFAnVkwIB3y5-.md index dede67d68..e2c2ab0ec 100644 --- a/src/data/roadmaps/system-design/content/availability-in-numbers@uHdrZllrZFAnVkwIB3y5-.md +++ b/src/data/roadmaps/system-design/content/availability-in-numbers@uHdrZllrZFAnVkwIB3y5-.md @@ -2,29 +2,30 @@ Availability is often quantified by uptime (or downtime) as a percentage of time the service is available. Availability is generally measured in number of 9s--a service with 99.99% availability is described as having four 9s. -## 99.9% Availability - Three 9s: +99.9% Availability - Three 9s: +------------------------------ -``` -Duration | Acceptable downtime -------------- | ------------- -Downtime per year | 8h 41min 38s -Downtime per month | 43m 28s -Downtime per week | 10m 4.8s -Downtime per day | 1m 26s -``` + Duration | Acceptable downtime + ------------- | ------------- + Downtime per year | 8h 41min 38s + Downtime per month | 43m 28s + Downtime per week | 10m 4.8s + Downtime per day | 1m 26s + -## 99.99% Availability - Four 9s +99.99% Availability - Four 9s +----------------------------- -``` -Duration | Acceptable downtime -------------- | ------------- -Downtime per year | 52min 9.8s -Downtime per month | 4m 21s -Downtime per week | 1m 0.5s -Downtime per day | 8.6s -``` + Duration | Acceptable downtime + ------------- | ------------- + Downtime per year | 52min 9.8s + Downtime per month | 4m 21s + Downtime per week | 1m 0.5s + Downtime per day | 8.6s + -## Availability in parallel vs in sequence +Availability in parallel vs in sequence +--------------------------------------- If a service consists of multiple components prone to failure, the service's overall availability depends on whether the components are in sequence or in parallel. @@ -32,9 +33,8 @@ If a service consists of multiple components prone to failure, the service's ove Overall availability decreases when two components with availability < 100% are in sequence: -``` -Availability (Total) = Availability (Foo) * Availability (Bar) -``` + Availability (Total) = Availability (Foo) * Availability (Bar) + If both `Foo` and `Bar` each had 99.9% availability, their total availability in sequence would be 99.8%. @@ -42,13 +42,12 @@ If both `Foo` and `Bar` each had 99.9% availability, their total availability in Overall availability increases when two components with availability < 100% are in parallel: -``` -Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar)) -``` + Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar)) + If both `Foo` and `Bar` each had 99.9% availability, their total availability in parallel would be 99.9999%. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Availability in System Design](https://www.enjoyalgorithms.com/blog/availability-system-design-concept/) -- [@article@Uptime calculator: How much downtime corresponds to 99.9 % uptime](https://uptime.is/) +- [@article@Uptime calculator: How much downtime corresponds to 99.9 % uptime](https://uptime.is/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/availability-monitoring@rVrwaioGURvrqNBufF2dj.md b/src/data/roadmaps/system-design/content/availability-monitoring@rVrwaioGURvrqNBufF2dj.md index 2a9d417e5..9967a8ecb 100644 --- a/src/data/roadmaps/system-design/content/availability-monitoring@rVrwaioGURvrqNBufF2dj.md +++ b/src/data/roadmaps/system-design/content/availability-monitoring@rVrwaioGURvrqNBufF2dj.md @@ -2,7 +2,7 @@ A truly healthy system requires that the components and subsystems that compose the system are available. Availability monitoring is closely related to health monitoring. But whereas health monitoring provides an immediate view of the current health of the system, availability monitoring is concerned with tracking the availability of the system and its components to generate statistics about the uptime of the system. -Learn more from the following: +Visit the following resources to learn more: - [@article@Availability Monitoring](https://learn.microsoft.com/en-us/azure/architecture/best-practices/monitoring#availability-monitoring) -- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) +- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/availability-patterns@ezptoTqeaepByegxS5kHL.md b/src/data/roadmaps/system-design/content/availability-patterns@ezptoTqeaepByegxS5kHL.md index db0c958b6..134c4045d 100644 --- a/src/data/roadmaps/system-design/content/availability-patterns@ezptoTqeaepByegxS5kHL.md +++ b/src/data/roadmaps/system-design/content/availability-patterns@ezptoTqeaepByegxS5kHL.md @@ -1,5 +1,9 @@ # Availability Patterns -Availability is measured as a percentage of uptime, and defines the proportion of time that a system is functional and working. Availability is affected by system errors, infrastructure problems, malicious attacks, and system load. Cloud applications typically provide users with a service level agreement (SLA), which means that applications must be designed and implemented to maximize availability. +Availability patterns are established architectural approaches used to ensure a system remains operational and accessible to users, even in the face of failures or unexpected events. These patterns focus on minimizing downtime and maintaining a consistent level of service by incorporating redundancy, fault tolerance, and recovery mechanisms into the system's design. They provide a structured way to address potential points of failure and ensure business continuity. -- [@article@Availability Patterns](https://learn.microsoft.com/en-us/azure/architecture/framework/resiliency/reliability-patterns#availability) +Visit the following resources to learn more: + +- [@article@High Availability in System Design – 15 Strategies for Always-On Systems](https://www.designgurus.io/blog/high-availability-system-design-basics) +- [@article@System Design: Availability Patterns](https://dev.to/decoders_lord/system-design-availability-patterns-104i) +- [@video@Design Patterns for High Availability: What gets you 99.999% uptime?](https://www.youtube.com/watch?v=LdvduBxZRLs) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/availability-vs-consistency@uJc27BNAuP321HQNbjftn.md b/src/data/roadmaps/system-design/content/availability-vs-consistency@uJc27BNAuP321HQNbjftn.md index afbadd0ff..62fe73f8a 100644 --- a/src/data/roadmaps/system-design/content/availability-vs-consistency@uJc27BNAuP321HQNbjftn.md +++ b/src/data/roadmaps/system-design/content/availability-vs-consistency@uJc27BNAuP321HQNbjftn.md @@ -6,9 +6,9 @@ Consistency, on the other hand, refers to the property that all clients see the In distributed systems, it is often a trade-off between availability and consistency. Systems that prioritize high availability may sacrifice consistency, while systems that prioritize consistency may sacrifice availability. Different distributed systems use different approaches to balance the trade-off between availability and consistency, such as using replication or consensus algorithms. -Have a look at the following resources to learn more: +Visit the following resources to learn more: -- [@video@CAP Theorem](https://www.youtube.com/watch?v=_RbsFXWRZ10&t=1s) +- [@opensource@CAP FAQ](https://github.com/henryr/cap-faq) - [@article@CAP Theorem Revisited](https://robertgreiner.com/cap-theorem-revisited/) - [@article@A plain english introduction to CAP Theorem](http://ksat.me/a-plain-english-introduction-to-cap-theorem) -- [@opensource@CAP FAQ](https://github.com/henryr/cap-faq) +- [@video@CAP Theorem](https://www.youtube.com/watch?v=_RbsFXWRZ10&t=1s) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/availability@Xzkvf4naveszLGV9b-8ih.md b/src/data/roadmaps/system-design/content/availability@Xzkvf4naveszLGV9b-8ih.md index 8eaed41cd..a1f730509 100644 --- a/src/data/roadmaps/system-design/content/availability@Xzkvf4naveszLGV9b-8ih.md +++ b/src/data/roadmaps/system-design/content/availability@Xzkvf4naveszLGV9b-8ih.md @@ -2,6 +2,6 @@ Availability is measured as a percentage of uptime, and defines the proportion of time that a system is functional and working. Availability is affected by system errors, infrastructure problems, malicious attacks, and system load. Cloud applications typically provide users with a service level agreement (SLA), which means that applications must be designed and implemented to maximize availability. -To learn more visit the following links: +Visit the following resources to learn more: -- [@article@Availability Patterns](https://learn.microsoft.com/en-us/azure/architecture/framework/resiliency/reliability-patterns#availability) +- [@article@Availability Patterns](https://learn.microsoft.com/en-us/azure/architecture/framework/resiliency/reliability-patterns#availability) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/back-pressure@YiYRZFE_zwPMiCZxz9FnP.md b/src/data/roadmaps/system-design/content/back-pressure@YiYRZFE_zwPMiCZxz9FnP.md index d512cc7fc..09ce53f1e 100644 --- a/src/data/roadmaps/system-design/content/back-pressure@YiYRZFE_zwPMiCZxz9FnP.md +++ b/src/data/roadmaps/system-design/content/back-pressure@YiYRZFE_zwPMiCZxz9FnP.md @@ -1,3 +1,3 @@ # Back Pressure -If queues start to grow significantly, the queue size can become larger than memory, resulting in cache misses, disk reads, and even slower performance. [Back pressure](http://mechanical-sympathy.blogspot.com/2012/05/apply-back-pressure-when-overloaded.html) can help by limiting the queue size, thereby maintaining a high throughput rate and good response times for jobs already in the queue. Once the queue fills up, clients get a server busy or HTTP 503 status code to try again later. Clients can retry the request at a later time, perhaps with [exponential backoff](https://en.wikipedia.org/wiki/Exponential_backoff). +If queues start to grow significantly, the queue size can become larger than memory, resulting in cache misses, disk reads, and even slower performance. [Back pressure](http://mechanical-sympathy.blogspot.com/2012/05/apply-back-pressure-when-overloaded.html) can help by limiting the queue size, thereby maintaining a high throughput rate and good response times for jobs already in the queue. Once the queue fills up, clients get a server busy or HTTP 503 status code to try again later. Clients can retry the request at a later time, perhaps with [exponential backoff](https://en.wikipedia.org/wiki/Exponential_backoff). \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/backends-for-frontend@n4It-lr7FFtSY83DcGydX.md b/src/data/roadmaps/system-design/content/backends-for-frontend@n4It-lr7FFtSY83DcGydX.md index d8e2f015a..d17fe5aeb 100644 --- a/src/data/roadmaps/system-design/content/backends-for-frontend@n4It-lr7FFtSY83DcGydX.md +++ b/src/data/roadmaps/system-design/content/backends-for-frontend@n4It-lr7FFtSY83DcGydX.md @@ -2,7 +2,7 @@ Create separate backend services to be consumed by specific frontend applications or interfaces. This pattern is useful when you want to avoid customizing a single backend for multiple interfaces. This pattern was first described by Sam Newman. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Backends for Frontends pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/backends-for-frontends) -- [@feed@Explore top posts about Frontend Development](https://app.daily.dev/tags/frontend?ref=roadmapsh) +- [@feed@Explore top posts about Frontend Development](https://app.daily.dev/tags/frontend?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/background-jobs@DOESIlBThd_wp2uOSd_CS.md b/src/data/roadmaps/system-design/content/background-jobs@DOESIlBThd_wp2uOSd_CS.md index 553d98b97..1da9275a7 100644 --- a/src/data/roadmaps/system-design/content/background-jobs@DOESIlBThd_wp2uOSd_CS.md +++ b/src/data/roadmaps/system-design/content/background-jobs@DOESIlBThd_wp2uOSd_CS.md @@ -4,11 +4,11 @@ Background jobs in system design refer to tasks that are executed in the backgro Background jobs can be used for a variety of purposes, such as: -- Performing maintenance tasks: such as cleaning up old data, generating reports, or backing up the database. -- Processing large volumes of data: such as data import, data export, or data transformation. -- Sending notifications or messages: such as sending email notifications or push notifications to users. -- Performing long-running computations: such as machine learning or data analysis. +* Performing maintenance tasks: such as cleaning up old data, generating reports, or backing up the database. +* Processing large volumes of data: such as data import, data export, or data transformation. +* Sending notifications or messages: such as sending email notifications or push notifications to users. +* Performing long-running computations: such as machine learning or data analysis. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Background Jobs - Best Practices](https://learn.microsoft.com/en-us/azure/architecture/best-practices/background-jobs) +- [@article@Background Jobs - Best Practices](https://learn.microsoft.com/en-us/azure/architecture/best-practices/background-jobs) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/bulkhead@IR2_kgs2U9rnAJiDBmpqK.md b/src/data/roadmaps/system-design/content/bulkhead@IR2_kgs2U9rnAJiDBmpqK.md index 615db5c89..831b33e35 100644 --- a/src/data/roadmaps/system-design/content/bulkhead@IR2_kgs2U9rnAJiDBmpqK.md +++ b/src/data/roadmaps/system-design/content/bulkhead@IR2_kgs2U9rnAJiDBmpqK.md @@ -2,7 +2,7 @@ The Bulkhead pattern is a type of application design that is tolerant of failure. In a bulkhead architecture, elements of an application are isolated into pools so that if one fails, the others will continue to function. It's named after the sectioned partitions (bulkheads) of a ship's hull. If the hull of a ship is compromised, only the damaged section fills with water, which prevents the ship from sinking. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Bulkhead pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/bulkhead) - [@article@Get started with Bulkhead](https://dzone.com/articles/resilient-microservices-pattern-bulkhead-pattern) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/bulkhead@PLn9TF9GYnPcbpTdDMQbG.md b/src/data/roadmaps/system-design/content/bulkhead@PLn9TF9GYnPcbpTdDMQbG.md index 615db5c89..831b33e35 100644 --- a/src/data/roadmaps/system-design/content/bulkhead@PLn9TF9GYnPcbpTdDMQbG.md +++ b/src/data/roadmaps/system-design/content/bulkhead@PLn9TF9GYnPcbpTdDMQbG.md @@ -2,7 +2,7 @@ The Bulkhead pattern is a type of application design that is tolerant of failure. In a bulkhead architecture, elements of an application are isolated into pools so that if one fails, the others will continue to function. It's named after the sectioned partitions (bulkheads) of a ship's hull. If the hull of a ship is compromised, only the damaged section fills with water, which prevents the ship from sinking. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Bulkhead pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/bulkhead) - [@article@Get started with Bulkhead](https://dzone.com/articles/resilient-microservices-pattern-bulkhead-pattern) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/busy-database@hxiV2uF7tvhZKe4K-4fTn.md b/src/data/roadmaps/system-design/content/busy-database@hxiV2uF7tvhZKe4K-4fTn.md index dde866618..be0ead512 100644 --- a/src/data/roadmaps/system-design/content/busy-database@hxiV2uF7tvhZKe4K-4fTn.md +++ b/src/data/roadmaps/system-design/content/busy-database@hxiV2uF7tvhZKe4K-4fTn.md @@ -2,7 +2,7 @@ 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: +Visit the following resources to learn more: - [@article@Busy Database antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/busy-database/) -- [@feed@Explore top posts about Database](https://app.daily.dev/tags/database?ref=roadmapsh) +- [@feed@Explore top posts about Database](https://app.daily.dev/tags/database?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/busy-frontend@i_2M3VloG-xTgWDWp4ngt.md b/src/data/roadmaps/system-design/content/busy-frontend@i_2M3VloG-xTgWDWp4ngt.md index 2d8173587..cf67e20b3 100644 --- a/src/data/roadmaps/system-design/content/busy-frontend@i_2M3VloG-xTgWDWp4ngt.md +++ b/src/data/roadmaps/system-design/content/busy-frontend@i_2M3VloG-xTgWDWp4ngt.md @@ -6,7 +6,7 @@ Resource-intensive tasks can increase the response times for user requests and c This problem typically occurs when an application is developed as monolithic piece of code, with all of the business logic combined into a single tier shared with the presentation layer. -To learn more about this and how to fix this pattern, visit the following link: +Visit the following resources to learn more: - [@article@Busy Front End antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/busy-front-end/) -- [@feed@Explore top posts about Frontend Development](https://app.daily.dev/tags/frontend?ref=roadmapsh) +- [@feed@Explore top posts about Frontend Development](https://app.daily.dev/tags/frontend?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/cache-aside@PK4V9OWNVi8StdA2N13X2.md b/src/data/roadmaps/system-design/content/cache-aside@PK4V9OWNVi8StdA2N13X2.md index 7176b8a46..9a4e5135d 100644 --- a/src/data/roadmaps/system-design/content/cache-aside@PK4V9OWNVi8StdA2N13X2.md +++ b/src/data/roadmaps/system-design/content/cache-aside@PK4V9OWNVi8StdA2N13X2.md @@ -2,6 +2,6 @@ Load data on demand into a cache from a data store. This can improve performance and also helps to maintain consistency between data held in the cache and data in the underlying data store. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Cache-Aside pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/cache-aside) +- [@article@Cache-Aside pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/cache-aside) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/cache-aside@bffJlvoLHFldS0CluWifP.md b/src/data/roadmaps/system-design/content/cache-aside@bffJlvoLHFldS0CluWifP.md index da1bdd045..89bcc11d4 100644 --- a/src/data/roadmaps/system-design/content/cache-aside@bffJlvoLHFldS0CluWifP.md +++ b/src/data/roadmaps/system-design/content/cache-aside@bffJlvoLHFldS0CluWifP.md @@ -2,26 +2,25 @@ The application is responsible for reading and writing from storage. The cache does not interact with storage directly. The application does the following: -- Look for entry in cache, resulting in a cache miss -- Load entry from the database -- Add entry to cache -- Return entry +* Look for entry in cache, resulting in a cache miss +* Load entry from the database +* Add entry to cache +* Return entry -```python -def get_user(self, user_id): - user = cache.get("user.{0}", user_id) - if user is None: - user = db.query("SELECT * FROM users WHERE user_id = {0}", user_id) - if user is not None: - key = "user.{0}".format(user_id) - cache.set(key, json.dumps(user)) - return user -``` + def get_user(self, user_id): + user = cache.get("user.{0}", user_id) + if user is None: + user = db.query("SELECT * FROM users WHERE user_id = {0}", user_id) + if user is not None: + key = "user.{0}".format(user_id) + cache.set(key, json.dumps(user)) + return user + [Memcached](https://memcached.org/) is generally used in this manner. Subsequent reads of data added to cache are fast. Cache-aside is also referred to as lazy loading. Only requested data is cached, which avoids filling up the cache with data that isn't requested. ![Cache Aside](https://i.imgur.com/Ujf0awN.png) -To learn more, have a look at the following resources: +Visit the following resources to learn more: -- [@article@From cache to in-memory data grid](https://www.slideshare.net/tmatyashovsky/from-cache-to-in-memory-data-grid-introduction-to-hazelcast) +- [@article@From cache to in-memory data grid](https://www.slideshare.net/tmatyashovsky/from-cache-to-in-memory-data-grid-introduction-to-hazelcast) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/caching@-X4g8kljgVBOBcf1DDzgi.md b/src/data/roadmaps/system-design/content/caching@-X4g8kljgVBOBcf1DDzgi.md index 878e05297..1d58b14e4 100644 --- a/src/data/roadmaps/system-design/content/caching@-X4g8kljgVBOBcf1DDzgi.md +++ b/src/data/roadmaps/system-design/content/caching@-X4g8kljgVBOBcf1DDzgi.md @@ -4,19 +4,19 @@ Caching is the process of storing frequently accessed data in a temporary storag There are several caching strategies: -- Refresh Ahead -- Write-Behind -- Write-through -- Cache Aside +* Refresh Ahead +* Write-Behind +* Write-through +* Cache Aside Also, you can have the cache in several places, examples include: -- Client Caching -- CDN Caching -- Web Server Caching -- Database Caching -- Application Caching +* Client Caching +* CDN Caching +* Web Server Caching +* Database Caching +* Application Caching -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Caching Strategies](https://medium.com/@mmoshikoo/cache-strategies-996e91c80303) +- [@article@Caching Strategies](https://medium.com/@mmoshikoo/cache-strategies-996e91c80303) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/cap-theorem@tcGdVQsCEobdV9hgOq3eG.md b/src/data/roadmaps/system-design/content/cap-theorem@tcGdVQsCEobdV9hgOq3eG.md index 7052d4888..e7b3d7c5f 100644 --- a/src/data/roadmaps/system-design/content/cap-theorem@tcGdVQsCEobdV9hgOq3eG.md +++ b/src/data/roadmaps/system-design/content/cap-theorem@tcGdVQsCEobdV9hgOq3eG.md @@ -2,25 +2,27 @@ According to CAP theorem, in a distributed system, you can only support two of the following guarantees: -- **Consistency** - Every read receives the most recent write or an error -- **Availability** - Every request receives a response, without guarantee that it contains the most recent version of the information -- **Partition Tolerance** - The system continues to operate despite arbitrary partitioning due to network failures +* **Consistency** - Every read receives the most recent write or an error +* **Availability** - Every request receives a response, without guarantee that it contains the most recent version of the information +* **Partition Tolerance** - The system continues to operate despite arbitrary partitioning due to network failures Networks aren't reliable, so you'll need to support partition tolerance. You'll need to make a software tradeoff between consistency and availability. -## CP - consistency and partition tolerance +CP - consistency and partition tolerance +---------------------------------------- Waiting for a response from the partitioned node might result in a timeout error. CP is a good choice if your business needs require atomic reads and writes. -## AP - availability and partition tolerance +AP - availability and partition tolerance +----------------------------------------- Responses return the most readily available version of the data available on any node, which might not be the latest. Writes might take some time to propagate when the partition is resolved. AP is a good choice if the business needs to allow for [eventual consistency](https://github.com/donnemartin/system-design-primer#eventual-consistency) or when the system needs to continue working despite external errors. -For more information, have a look at the following resources: +Visit the following resources to learn more: +- [@opensource@CAP FAQ](https://github.com/henryr/cap-faq) - [@article@CAP theorem revisited](http://robertgreiner.com/2014/08/cap-theorem-revisited/) - [@article@A plain english introduction to CAP theorem](http://ksat.me/a-plain-english-introduction-to-cap-theorem) -- [@opensource@CAP FAQ](https://github.com/henryr/cap-faq) -- [@video@The CAP theorem](https://www.youtube.com/watch?v=k-Yaq8AHlFA) +- [@video@The CAP theorem](https://www.youtube.com/watch?v=k-Yaq8AHlFA) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/cdn-caching@Kisvxlrjb7XnKFCOdxRtb.md b/src/data/roadmaps/system-design/content/cdn-caching@Kisvxlrjb7XnKFCOdxRtb.md index 0568af197..07b3ea040 100644 --- a/src/data/roadmaps/system-design/content/cdn-caching@Kisvxlrjb7XnKFCOdxRtb.md +++ b/src/data/roadmaps/system-design/content/cdn-caching@Kisvxlrjb7XnKFCOdxRtb.md @@ -4,4 +4,4 @@ A Content Delivery Network (CDN) is a distributed network of servers that are st When a user requests content from a website that is using a CDN, the CDN will first check if the requested content is available in the cache of a nearby server. If the content is found in the cache, it is served to the user from the nearby server. If the content is not found in the cache, it is requested from the origin server (the original source of the content) and then cached on the nearby server for future requests. -CDN caching can significantly improve the performance and availability of a website by reducing the distance that data needs to travel, reducing the load on the origin server, and allowing for faster delivery of content to end-users. +CDN caching can significantly improve the performance and availability of a website by reducing the distance that data needs to travel, reducing the load on the origin server, and allowing for faster delivery of content to end-users. \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/chatty-io@0IzQwuYi_E00bJwxDuw2B.md b/src/data/roadmaps/system-design/content/chatty-io@0IzQwuYi_E00bJwxDuw2B.md index 6e9ed3e3f..f8215829c 100644 --- a/src/data/roadmaps/system-design/content/chatty-io@0IzQwuYi_E00bJwxDuw2B.md +++ b/src/data/roadmaps/system-design/content/chatty-io@0IzQwuYi_E00bJwxDuw2B.md @@ -4,10 +4,10 @@ The cumulative effect of a large number of I/O requests can have a significant i Network calls and other I/O operations are inherently slow compared to compute tasks. Each I/O request typically has significant overhead, and the cumulative effect of numerous I/O operations can slow down the system. Here are some common causes of chatty I/O. -- Reading and writing individual records to a database as distinct requests -- Implementing a single logical operation as a series of HTTP requests -- Reading and writing to a file on disk +* Reading and writing individual records to a database as distinct requests +* Implementing a single logical operation as a series of HTTP requests +* Reading and writing to a file on disk -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Chatty I/O antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/chatty-io/) +- [@article@Chatty I/O antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/chatty-io/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/choreography@aCzRgUkVBvtHUeLU6p5ZH.md b/src/data/roadmaps/system-design/content/choreography@aCzRgUkVBvtHUeLU6p5ZH.md index 9fef00452..95beb6359 100644 --- a/src/data/roadmaps/system-design/content/choreography@aCzRgUkVBvtHUeLU6p5ZH.md +++ b/src/data/roadmaps/system-design/content/choreography@aCzRgUkVBvtHUeLU6p5ZH.md @@ -2,6 +2,6 @@ Have each component of the system participate in the decision-making process about the workflow of a business transaction, instead of relying on a central point of control. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Choreography pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/choreography) +- [@article@Choreography pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/choreography) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/circuit-breaker@D1OmCoqvd3-_af3u0ciHr.md b/src/data/roadmaps/system-design/content/circuit-breaker@D1OmCoqvd3-_af3u0ciHr.md index 5d11e7761..0396420ee 100644 --- a/src/data/roadmaps/system-design/content/circuit-breaker@D1OmCoqvd3-_af3u0ciHr.md +++ b/src/data/roadmaps/system-design/content/circuit-breaker@D1OmCoqvd3-_af3u0ciHr.md @@ -2,7 +2,7 @@ Handle faults that might take a variable amount of time to recover from, when connecting to a remote service or resource. This can improve the stability and resiliency of an application. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Circuit breaker design pattern](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern) - [@article@Overview of Circuit Breaker](https://medium.com/geekculture/design-patterns-for-microservices-circuit-breaker-pattern-276249ffab33) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/circuit-breaker@O4zYDqvVWD7sMI27k_0Nl.md b/src/data/roadmaps/system-design/content/circuit-breaker@O4zYDqvVWD7sMI27k_0Nl.md index 5d11e7761..0396420ee 100644 --- a/src/data/roadmaps/system-design/content/circuit-breaker@O4zYDqvVWD7sMI27k_0Nl.md +++ b/src/data/roadmaps/system-design/content/circuit-breaker@O4zYDqvVWD7sMI27k_0Nl.md @@ -2,7 +2,7 @@ Handle faults that might take a variable amount of time to recover from, when connecting to a remote service or resource. This can improve the stability and resiliency of an application. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Circuit breaker design pattern](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern) - [@article@Overview of Circuit Breaker](https://medium.com/geekculture/design-patterns-for-microservices-circuit-breaker-pattern-276249ffab33) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/claim-check@kl4upCnnZvJSf2uII1Pa0.md b/src/data/roadmaps/system-design/content/claim-check@kl4upCnnZvJSf2uII1Pa0.md index e89edede7..9f0406334 100644 --- a/src/data/roadmaps/system-design/content/claim-check@kl4upCnnZvJSf2uII1Pa0.md +++ b/src/data/roadmaps/system-design/content/claim-check@kl4upCnnZvJSf2uII1Pa0.md @@ -2,6 +2,6 @@ Split a large message into a claim check and a payload. Send the claim check to the messaging platform and store the payload to an external service. This pattern allows large messages to be processed, while protecting the message bus and the client from being overwhelmed or slowed down. This pattern also helps to reduce costs, as storage is usually cheaper than resource units used by the messaging platform. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Claim Check - Cloud Design patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/claim-check) +- [@article@Claim Check - Cloud Design patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/claim-check) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/client-caching@RHNRb6QWiGvCK3KQOPK3u.md b/src/data/roadmaps/system-design/content/client-caching@RHNRb6QWiGvCK3KQOPK3u.md index 7d1269778..ac68ddfe4 100644 --- a/src/data/roadmaps/system-design/content/client-caching@RHNRb6QWiGvCK3KQOPK3u.md +++ b/src/data/roadmaps/system-design/content/client-caching@RHNRb6QWiGvCK3KQOPK3u.md @@ -8,6 +8,6 @@ Another example of client-side caching is application-level caching. Some applic Client side caching has some advantages like reducing server load, faster page load times, and reducing network traffic. However, it also has some drawbacks like the potential for stale data if the client-side cache is not properly managed, or consuming memory or disk space on the client's device. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@HTTP Caching](https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching) +- [@article@HTTP Caching](https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/cloud-design-patterns@THlzcZTNnPGLRiHPWT-Jv.md b/src/data/roadmaps/system-design/content/cloud-design-patterns@THlzcZTNnPGLRiHPWT-Jv.md index b441d62a9..7b62d2b8f 100644 --- a/src/data/roadmaps/system-design/content/cloud-design-patterns@THlzcZTNnPGLRiHPWT-Jv.md +++ b/src/data/roadmaps/system-design/content/cloud-design-patterns@THlzcZTNnPGLRiHPWT-Jv.md @@ -2,7 +2,7 @@ Cloud design patterns are solutions to common problems that arise when building systems that run on a cloud platform. These patterns provide a way to design and implement systems that can take advantage of the unique characteristics of the cloud, such as scalability, elasticity, and pay-per-use pricing. Some common cloud design patterns include Scalability, Elasticity, Fault Tolerance, Microservices, Serverless, Data Management, Front-end and Back-end separation and Hybrid. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Cloud Design Patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/) -- [@feed@Explore top posts about Cloud](https://app.daily.dev/tags/cloud?ref=roadmapsh) +- [@feed@Explore top posts about Cloud](https://app.daily.dev/tags/cloud?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/communication@uQFzD_ryd-8Dr1ppjorYJ.md b/src/data/roadmaps/system-design/content/communication@uQFzD_ryd-8Dr1ppjorYJ.md index 0ee565174..addedcd0b 100644 --- a/src/data/roadmaps/system-design/content/communication@uQFzD_ryd-8Dr1ppjorYJ.md +++ b/src/data/roadmaps/system-design/content/communication@uQFzD_ryd-8Dr1ppjorYJ.md @@ -1,3 +1,3 @@ # Communication -Network protocols are a key part of systems today, as no system can exist in isolation - they all need to communicate with each other. You should learn about the networking protocols such as HTTP, TCP, UDP. Also, learn about the architectural styles such as RPC, REST, GraphQL and gRPC. +Network protocols are a key part of systems today, as no system can exist in isolation - they all need to communicate with each other. You should learn about the networking protocols such as HTTP, TCP, UDP. Also, learn about the architectural styles such as RPC, REST, GraphQL and gRPC. \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/compensating-transaction@MNlWNjrG8eh5OzPVlbb9t.md b/src/data/roadmaps/system-design/content/compensating-transaction@MNlWNjrG8eh5OzPVlbb9t.md index 1c0d99e24..b7408ca6d 100644 --- a/src/data/roadmaps/system-design/content/compensating-transaction@MNlWNjrG8eh5OzPVlbb9t.md +++ b/src/data/roadmaps/system-design/content/compensating-transaction@MNlWNjrG8eh5OzPVlbb9t.md @@ -2,7 +2,7 @@ Undo the work performed by a series of steps, which together define an eventually consistent operation, if one or more of the steps fail. Operations that follow the eventual consistency model are commonly found in cloud-hosted applications that implement complex business processes and workflows. -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Compensating Transaction pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/compensating-transaction) - [@article@Intro to Compensation Transaction](https://en.wikipedia.org/wiki/Compensating_transaction) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/competing-consumers@9Ld07KLOqP0ICtXEjngYM.md b/src/data/roadmaps/system-design/content/competing-consumers@9Ld07KLOqP0ICtXEjngYM.md index 3afc3b8fb..998b71adb 100644 --- a/src/data/roadmaps/system-design/content/competing-consumers@9Ld07KLOqP0ICtXEjngYM.md +++ b/src/data/roadmaps/system-design/content/competing-consumers@9Ld07KLOqP0ICtXEjngYM.md @@ -2,6 +2,6 @@ Enable multiple concurrent consumers to process messages received on the same messaging channel. With multiple concurrent consumers, a system can process multiple messages concurrently to optimize throughput, to improve scalability and availability, and to balance the workload. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Competing Consumers pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/competing-consumers) +- [@article@Competing Consumers pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/competing-consumers) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/compute-resource-consolidation@ODjVoXnvJasPvCS2A5iMO.md b/src/data/roadmaps/system-design/content/compute-resource-consolidation@ODjVoXnvJasPvCS2A5iMO.md index 94791c354..87f5e75a3 100644 --- a/src/data/roadmaps/system-design/content/compute-resource-consolidation@ODjVoXnvJasPvCS2A5iMO.md +++ b/src/data/roadmaps/system-design/content/compute-resource-consolidation@ODjVoXnvJasPvCS2A5iMO.md @@ -2,6 +2,6 @@ Consolidate multiple tasks or operations into a single computational unit. This can increase compute resource utilization, and reduce the costs and management overhead associated with performing compute processing in cloud-hosted applications. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Compute Resource Consolidation pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/compute-resource-consolidation) +- [@article@Compute Resource Consolidation pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/compute-resource-consolidation) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/consistency-patterns@GHe8V-REu1loRpDnHbyUn.md b/src/data/roadmaps/system-design/content/consistency-patterns@GHe8V-REu1loRpDnHbyUn.md index 615abe1c3..68bfa8ff4 100644 --- a/src/data/roadmaps/system-design/content/consistency-patterns@GHe8V-REu1loRpDnHbyUn.md +++ b/src/data/roadmaps/system-design/content/consistency-patterns@GHe8V-REu1loRpDnHbyUn.md @@ -2,12 +2,12 @@ Consistency patterns refer to the ways in which data is stored and managed in a distributed system, and how that data is made available to users and applications. There are three main types of consistency patterns: -- Strong consistency -- Weak consistency -- Eventual Consistency +* Strong consistency +* Weak consistency +* Eventual Consistency Each of these patterns has its own advantages and disadvantages, and the choice of which pattern to use will depend on the specific requirements of the application or system. -Have a look at the following resources to learn more: +Visit the following resources to learn more: -- [@article@Consistency Patterns in Distributed Systems](https://cs.fyi/guide/consistency-patterns-week-strong-eventual/) +- [@article@Consistency Patterns in Distributed Systems](https://cs.fyi/guide/consistency-patterns-week-strong-eventual/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/content-delivery-networks@O730v5Ww3ByAiBSs6fwyM.md b/src/data/roadmaps/system-design/content/content-delivery-networks@O730v5Ww3ByAiBSs6fwyM.md index 58a329dda..b050203f0 100644 --- a/src/data/roadmaps/system-design/content/content-delivery-networks@O730v5Ww3ByAiBSs6fwyM.md +++ b/src/data/roadmaps/system-design/content/content-delivery-networks@O730v5Ww3ByAiBSs6fwyM.md @@ -4,11 +4,11 @@ A content delivery network (CDN) is a globally distributed network of proxy serv Serving content from CDNs can significantly improve performance in two ways: -- Users receive content from data centers close to them -- Your servers do not have to serve requests that the CDN fulfills +* Users receive content from data centers close to them +* Your servers do not have to serve requests that the CDN fulfills -Learn more about CDNs from the following links: +Visit the following resources to learn more: - [@opensource@Introduction to CDNs](https://github.com/donnemartin/system-design-primer#content-delivery-network) - [@article@The Differences Between Push And Pull CDNs](http://www.travelblogadvice.com/technical/the-differences-between-push-and-pull-cdns/) -- [@article@Brief about Content delivery network](https://en.wikipedia.org/wiki/Content_delivery_network) +- [@article@Brief about Content delivery network](https://en.wikipedia.org/wiki/Content_delivery_network) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/cqrs@LTD3dn05c0ruUJW0IQO7z.md b/src/data/roadmaps/system-design/content/cqrs@LTD3dn05c0ruUJW0IQO7z.md index ff706d66c..09265982b 100644 --- a/src/data/roadmaps/system-design/content/cqrs@LTD3dn05c0ruUJW0IQO7z.md +++ b/src/data/roadmaps/system-design/content/cqrs@LTD3dn05c0ruUJW0IQO7z.md @@ -2,6 +2,6 @@ CQRS stands for Command and Query Responsibility Segregation, a pattern that separates read and update operations for a data store. Implementing CQRS in your application can maximize its performance, scalability, and security. The flexibility created by migrating to CQRS allows a system to better evolve over time and prevents update commands from causing merge conflicts at the domain level. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@CQRS pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs) +- [@article@CQRS pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/cqrs@ivr3mh0OES5n86FI1PN4N.md b/src/data/roadmaps/system-design/content/cqrs@ivr3mh0OES5n86FI1PN4N.md index ff706d66c..09265982b 100644 --- a/src/data/roadmaps/system-design/content/cqrs@ivr3mh0OES5n86FI1PN4N.md +++ b/src/data/roadmaps/system-design/content/cqrs@ivr3mh0OES5n86FI1PN4N.md @@ -2,6 +2,6 @@ CQRS stands for Command and Query Responsibility Segregation, a pattern that separates read and update operations for a data store. Implementing CQRS in your application can maximize its performance, scalability, and security. The flexibility created by migrating to CQRS allows a system to better evolve over time and prevents update commands from causing merge conflicts at the domain level. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@CQRS pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs) +- [@article@CQRS pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/data-management@W0cUCrhiwH_Nrzxw50x3L.md b/src/data/roadmaps/system-design/content/data-management@W0cUCrhiwH_Nrzxw50x3L.md index 136ad5b1a..3089665e0 100644 --- a/src/data/roadmaps/system-design/content/data-management@W0cUCrhiwH_Nrzxw50x3L.md +++ b/src/data/roadmaps/system-design/content/data-management@W0cUCrhiwH_Nrzxw50x3L.md @@ -2,7 +2,7 @@ Data management is the key element of cloud applications, and influences most of the quality attributes. Data is typically hosted in different locations and across multiple servers for reasons such as performance, scalability or availability, and this can present a range of challenges. For example, data consistency must be maintained, and data will typically need to be synchronized across different locations. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Data management patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/category/data-management) -- [@feed@Explore top posts about Data Management](https://app.daily.dev/tags/data-management?ref=roadmapsh) +- [@feed@Explore top posts about Data Management](https://app.daily.dev/tags/data-management?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/database-caching@BeIg4jzbij2cwc_a_VpYG.md b/src/data/roadmaps/system-design/content/database-caching@BeIg4jzbij2cwc_a_VpYG.md index b82a0504b..237d6f347 100644 --- a/src/data/roadmaps/system-design/content/database-caching@BeIg4jzbij2cwc_a_VpYG.md +++ b/src/data/roadmaps/system-design/content/database-caching@BeIg4jzbij2cwc_a_VpYG.md @@ -2,14 +2,15 @@ Your database usually includes some level of caching in a default configuration, optimized for a generic use case. Tweaking these settings for specific usage patterns can further boost performance. it's like having a quick-access memory for frequently used data in applications. Here's a simplified explanation: -1. **Quick Access**: Imagine you're looking up information in a big library (the database). Instead of going to the library every time you need the same book (data), you keep a copy of it on your desk (cache). +1. **Quick Access**: Imagine you're looking up information in a big library (the database). Instead of going to the library every time you need the same book (data), you keep a copy of it on your desk (cache). + +2. **Faster Retrieval**: When you need that book again, you first check your desk (cache). If it's there, great! You get it right away without going to the library (database) again. + +3. **Saving Time**: If the book isn't on your desk (cache miss), you go to the library (database) to get it. But you make sure to put a copy on your desk for next time, so you won't have to go to the library again if you need it soon. + +4. **Different Types**: There are different ways to do this caching. You can cache the results of searches (like bookmarking), whole pieces of information (like keeping a paper copy), or even entire web pages (like saving a snapshot). + +5. **Benefits**: By keeping frequently used data close by, you save time and reduce the strain on the library (database). It's like having your most-used books right at your fingertips, making your work faster and more efficient. + -2. **Faster Retrieval**: When you need that book again, you first check your desk (cache). If it's there, great! You get it right away without going to the library (database) again. - -3. **Saving Time**: If the book isn't on your desk (cache miss), you go to the library (database) to get it. But you make sure to put a copy on your desk for next time, so you won't have to go to the library again if you need it soon. - -4. **Different Types**: There are different ways to do this caching. You can cache the results of searches (like bookmarking), whole pieces of information (like keeping a paper copy), or even entire web pages (like saving a snapshot). - -5. **Benefits**: By keeping frequently used data close by, you save time and reduce the strain on the library (database). It's like having your most-used books right at your fingertips, making your work faster and more efficient. - -However, it's important to keep the cached data up to date. Otherwise, you might end up with outdated information, like using an old edition of a book instead of the latest one. So, managing this cache properly is key to keeping things running smoothly. +However, it's important to keep the cached data up to date. Otherwise, you might end up with outdated information, like using an old edition of a book instead of the latest one. So, managing this cache properly is key to keeping things running smoothly. \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/databases@5FXwwRMNBhG7LT5ub6t2L.md b/src/data/roadmaps/system-design/content/databases@5FXwwRMNBhG7LT5ub6t2L.md index 438e44880..d3b55c259 100644 --- a/src/data/roadmaps/system-design/content/databases@5FXwwRMNBhG7LT5ub6t2L.md +++ b/src/data/roadmaps/system-design/content/databases@5FXwwRMNBhG7LT5ub6t2L.md @@ -2,13 +2,13 @@ Picking the right database for a system is an important decision, as it can have a significant impact on the performance, scalability, and overall success of the system. Some of the key reasons why it's important to pick the right database include: -- Performance: Different databases have different performance characteristics, and choosing the wrong one can lead to poor performance and slow response times. -- Scalability: As the system grows and the volume of data increases, the database needs to be able to scale accordingly. Some databases are better suited for handling large amounts of data than others. -- Data Modeling: Different databases have different data modeling capabilities and choosing the right one can help to keep the data consistent and organized. -- Data Integrity: Different databases have different capabilities for maintaining data integrity, such as enforcing constraints, and can have different levels of data security. -- Support and maintenance: Some databases have more active communities and better documentation, making it easier to find help and resources. +* Performance: Different databases have different performance characteristics, and choosing the wrong one can lead to poor performance and slow response times. +* Scalability: As the system grows and the volume of data increases, the database needs to be able to scale accordingly. Some databases are better suited for handling large amounts of data than others. +* Data Modeling: Different databases have different data modeling capabilities and choosing the right one can help to keep the data consistent and organized. +* Data Integrity: Different databases have different capabilities for maintaining data integrity, such as enforcing constraints, and can have different levels of data security. +* Support and maintenance: Some databases have more active communities and better documentation, making it easier to find help and resources. -Overall, by choosing the right database, you can ensure that your system will perform well, scale as needed, and be maintainable in the long run. +Visit the following resources to learn more: - [@video@Scaling up to your first 10 million users](https://www.youtube.com/watch?v=kKjm4ehYiMs) -- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh) +- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/denormalization@Zp9D4--DgtlAjE2nIfaO_.md b/src/data/roadmaps/system-design/content/denormalization@Zp9D4--DgtlAjE2nIfaO_.md index 5fc40f295..c800bab34 100644 --- a/src/data/roadmaps/system-design/content/denormalization@Zp9D4--DgtlAjE2nIfaO_.md +++ b/src/data/roadmaps/system-design/content/denormalization@Zp9D4--DgtlAjE2nIfaO_.md @@ -4,6 +4,6 @@ Denormalization attempts to improve read performance at the expense of some writ Once data becomes distributed with techniques such as federation and sharding, managing joins across data centers further increases complexity. Denormalization might circumvent the need for such complex joins. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Denormalization](https://en.wikipedia.org/wiki/Denormalization) +- [@article@Denormalization](https://en.wikipedia.org/wiki/Denormalization) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/deployment-stamps@FPPJw-I1cw8OxKwmDh0dT.md b/src/data/roadmaps/system-design/content/deployment-stamps@FPPJw-I1cw8OxKwmDh0dT.md index 3d480a1c9..4bef47916 100644 --- a/src/data/roadmaps/system-design/content/deployment-stamps@FPPJw-I1cw8OxKwmDh0dT.md +++ b/src/data/roadmaps/system-design/content/deployment-stamps@FPPJw-I1cw8OxKwmDh0dT.md @@ -2,7 +2,7 @@ The deployment stamp pattern involves provisioning, managing, and monitoring a heterogeneous group of resources to host and operate multiple workloads or tenants. Each individual copy is called a stamp, or sometimes a service unit, scale unit, or cell. In a multi-tenant environment, every stamp or scale unit can serve a predefined number of tenants. Multiple stamps can be deployed to scale the solution almost linearly and serve an increasing number of tenants. This approach can improve the scalability of your solution, allow you to deploy instances across multiple regions, and separate your customer data. -To learn more visit the following links: +Visit the following resources to learn more: - [@article@Deployment Stamps pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/deployment-stamp) - [@article@Deployment Stamps 101](https://blog.devgenius.io/deployment-stamps-101-7c04a6f704a2) diff --git a/src/data/roadmaps/system-design/content/deployment-stamps@Ze471tPbAwlwZyU4oIzH9.md b/src/data/roadmaps/system-design/content/deployment-stamps@Ze471tPbAwlwZyU4oIzH9.md index 3d480a1c9..4bef47916 100644 --- a/src/data/roadmaps/system-design/content/deployment-stamps@Ze471tPbAwlwZyU4oIzH9.md +++ b/src/data/roadmaps/system-design/content/deployment-stamps@Ze471tPbAwlwZyU4oIzH9.md @@ -2,7 +2,7 @@ The deployment stamp pattern involves provisioning, managing, and monitoring a heterogeneous group of resources to host and operate multiple workloads or tenants. Each individual copy is called a stamp, or sometimes a service unit, scale unit, or cell. In a multi-tenant environment, every stamp or scale unit can serve a predefined number of tenants. Multiple stamps can be deployed to scale the solution almost linearly and serve an increasing number of tenants. This approach can improve the scalability of your solution, allow you to deploy instances across multiple regions, and separate your customer data. -To learn more visit the following links: +Visit the following resources to learn more: - [@article@Deployment Stamps pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/deployment-stamp) - [@article@Deployment Stamps 101](https://blog.devgenius.io/deployment-stamps-101-7c04a6f704a2) diff --git a/src/data/roadmaps/system-design/content/design--implementation@PtJ7-v1VCLsyaWWYHYujV.md b/src/data/roadmaps/system-design/content/design--implementation@PtJ7-v1VCLsyaWWYHYujV.md index b3a27c248..0651b136f 100644 --- a/src/data/roadmaps/system-design/content/design--implementation@PtJ7-v1VCLsyaWWYHYujV.md +++ b/src/data/roadmaps/system-design/content/design--implementation@PtJ7-v1VCLsyaWWYHYujV.md @@ -2,6 +2,6 @@ Good design encompasses factors such as consistency and coherence in component design and deployment, maintainability to simplify administration and development, and reusability to allow components and subsystems to be used in other applications and in other scenarios. Decisions made during the design and implementation phase have a huge impact on the quality and the total cost of ownership of cloud hosted applications and services. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Design and implementation patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/category/design-implementation) +- [@article@Design and implementation patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/category/design-implementation) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/document-store@didEznSlVHqqlijtyOSr3.md b/src/data/roadmaps/system-design/content/document-store@didEznSlVHqqlijtyOSr3.md index 6bad37765..ee2692108 100644 --- a/src/data/roadmaps/system-design/content/document-store@didEznSlVHqqlijtyOSr3.md +++ b/src/data/roadmaps/system-design/content/document-store@didEznSlVHqqlijtyOSr3.md @@ -4,6 +4,6 @@ A document store is centered around documents (XML, JSON, binary, etc), where a Based on the underlying implementation, documents are organized by collections, tags, metadata, or directories. Although documents can be organized or grouped together, documents may have fields that are completely different from each other. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Document-oriented database](https://en.wikipedia.org/wiki/Document-oriented_database) +- [@article@Document-oriented database](https://en.wikipedia.org/wiki/Document-oriented_database) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/domain-name-system@Uk6J8JRcKVEFz4_8rLfnQ.md b/src/data/roadmaps/system-design/content/domain-name-system@Uk6J8JRcKVEFz4_8rLfnQ.md index 646badca2..ed28fa7f6 100644 --- a/src/data/roadmaps/system-design/content/domain-name-system@Uk6J8JRcKVEFz4_8rLfnQ.md +++ b/src/data/roadmaps/system-design/content/domain-name-system@Uk6J8JRcKVEFz4_8rLfnQ.md @@ -1,24 +1,24 @@ # Domain Name System -A Domain Name System (DNS) translates a domain name such as www.example.com to an IP address. +A Domain Name System (DNS) translates a domain name such as [www.example.com](http://www.example.com) to an IP address. DNS is hierarchical, with a few authoritative servers at the top level. Your router or ISP provides information about which DNS server(s) to contact when doing a lookup. Lower level DNS servers cache mappings, which could become stale due to DNS propagation delays. DNS results can also be cached by your browser or OS for a certain period of time, determined by the time to live (TTL). -- NS record (name server) - Specifies the DNS servers for your domain/subdomain. -- MX record (mail exchange) - Specifies the mail servers for accepting messages. -- A record (address) - Points a name to an IP address. -- CNAME (canonical) - Points a name to another name or CNAME (example.com to www.example.com) or to an A record. +* NS record (name server) - Specifies the DNS servers for your domain/subdomain. +* MX record (mail exchange) - Specifies the mail servers for accepting messages. +* A record (address) - Points a name to an IP address. +* CNAME (canonical) - Points a name to another name or CNAME ([example.com](http://example.com) to [www.example.com](http://www.example.com)) or to an A record. Services such as [CloudFlare](https://www.cloudflare.com/dns/) and [Route53](https://aws.amazon.com/route53/) provide managed DNS services. Some DNS services can route traffic through various methods: -- [@article@Weighted Round Robin](https://www.jscape.com/blog/load-balancing-algorithms) - - Prevent traffic from going to servers under maintenance - - Balance between varying cluster sizes - - A/B testing -- [@article@Latency Based](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-latency) -- [@article@Geolocation Based](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-geo) +* [@article@Weighted Round Robin](https://www.jscape.com/blog/load-balancing-algorithms) + * Prevent traffic from going to servers under maintenance + * Balance between varying cluster sizes + * A/B testing +* [@article@Latency Based](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-latency) +* [@article@Geolocation Based](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-geo) -To learn more, visit the following links: +Visit the following resources to learn more: - [@opensource@Getting started with Domain Name System](https://github.com/donnemartin/system-design-primer#domain-name-system) -- [@article@What is DNS?](https://www.cloudflare.com/learning/dns/what-is-dns/) +- [@article@What is DNS?](https://www.cloudflare.com/learning/dns/what-is-dns/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/event-driven@NEsPjQifNDlZJE-2YLVl1.md b/src/data/roadmaps/system-design/content/event-driven@NEsPjQifNDlZJE-2YLVl1.md index e1b07075c..0ad77c88b 100644 --- a/src/data/roadmaps/system-design/content/event-driven@NEsPjQifNDlZJE-2YLVl1.md +++ b/src/data/roadmaps/system-design/content/event-driven@NEsPjQifNDlZJE-2YLVl1.md @@ -2,10 +2,10 @@ Event-driven invocation uses a trigger to start the background task. Examples of using event-driven triggers include: -- The UI or another job places a message in a queue. The message contains data about an action that has taken place, such as the user placing an order. The background task listens on this queue and detects the arrival of a new message. It reads the message and uses the data in it as the input to the background job. This pattern is known as asynchronous message-based communication. -- The UI or another job saves or updates a value in storage. The background task monitors the storage and detects changes. It reads the data and uses it as the input to the background job. -- The UI or another job makes a request to an endpoint, such as an HTTPS URI, or an API that is exposed as a web service. It passes the data that is required to complete the background task as part of the request. The endpoint or web service invokes the background task, which uses the data as its input. +* The UI or another job places a message in a queue. The message contains data about an action that has taken place, such as the user placing an order. The background task listens on this queue and detects the arrival of a new message. It reads the message and uses the data in it as the input to the background job. This pattern is known as asynchronous message-based communication. +* The UI or another job saves or updates a value in storage. The background task monitors the storage and detects changes. It reads the data and uses it as the input to the background job. +* The UI or another job makes a request to an endpoint, such as an HTTPS URI, or an API that is exposed as a web service. It passes the data that is required to complete the background task as part of the request. The endpoint or web service invokes the background task, which uses the data as its input. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Background Jobs - Event Driven Triggers](https://learn.microsoft.com/en-us/azure/architecture/best-practices/background-jobs#event-driven-triggers) +- [@article@Background Jobs - Event Driven Triggers](https://learn.microsoft.com/en-us/azure/architecture/best-practices/background-jobs#event-driven-triggers) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/event-sourcing@7OgRKlwFqrk3XO2z49EI1.md b/src/data/roadmaps/system-design/content/event-sourcing@7OgRKlwFqrk3XO2z49EI1.md index 570d38143..51776b502 100644 --- a/src/data/roadmaps/system-design/content/event-sourcing@7OgRKlwFqrk3XO2z49EI1.md +++ b/src/data/roadmaps/system-design/content/event-sourcing@7OgRKlwFqrk3XO2z49EI1.md @@ -2,7 +2,7 @@ Instead of storing just the current state of the data in a domain, use an append-only store to record the full series of actions taken on that data. The store acts as the system of record and can be used to materialize the domain objects. This can simplify tasks in complex domains, by avoiding the need to synchronize the data model and the business domain, while improving performance, scalability, and responsiveness. It can also provide consistency for transactional data, and maintain full audit trails and history that can enable compensating actions. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Event Sourcing pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/event-sourcing) -- [@feed@Explore top posts about Architecture](https://app.daily.dev/tags/architecture?ref=roadmapsh) +- [@feed@Explore top posts about Architecture](https://app.daily.dev/tags/architecture?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/eventual-consistency@rRDGVynX43inSeQ9lR_FS.md b/src/data/roadmaps/system-design/content/eventual-consistency@rRDGVynX43inSeQ9lR_FS.md index 59e5237f6..a73e392cb 100644 --- a/src/data/roadmaps/system-design/content/eventual-consistency@rRDGVynX43inSeQ9lR_FS.md +++ b/src/data/roadmaps/system-design/content/eventual-consistency@rRDGVynX43inSeQ9lR_FS.md @@ -2,6 +2,6 @@ Eventual consistency is a form of Weak Consistency. After an update is made to the data, it will be eventually visible to any subsequent read operations. The data is replicated in an asynchronous manner, ensuring that all copies of the data are eventually updated. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Consistency Patterns in Distributed Systems](https://cs.fyi/guide/consistency-patterns-week-strong-eventual/) +- [@article@Consistency Patterns in Distributed Systems](https://cs.fyi/guide/consistency-patterns-week-strong-eventual/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/external-config-store@BrgXwf7g2F-6Rqfjryvpj.md b/src/data/roadmaps/system-design/content/external-config-store@BrgXwf7g2F-6Rqfjryvpj.md index 0596fc56d..7a260bd82 100644 --- a/src/data/roadmaps/system-design/content/external-config-store@BrgXwf7g2F-6Rqfjryvpj.md +++ b/src/data/roadmaps/system-design/content/external-config-store@BrgXwf7g2F-6Rqfjryvpj.md @@ -2,6 +2,6 @@ Move configuration information out of the application deployment package to a centralized location. This can provide opportunities for easier management and control of configuration data, and for sharing configuration data across applications and application instances. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@External Configuration Store pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/external-configuration-store) +- [@article@External Configuration Store pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/external-configuration-store) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/extraneous-fetching@6u3XmtJFWyJnyZUnJcGYb.md b/src/data/roadmaps/system-design/content/extraneous-fetching@6u3XmtJFWyJnyZUnJcGYb.md index 824671af3..21669236b 100644 --- a/src/data/roadmaps/system-design/content/extraneous-fetching@6u3XmtJFWyJnyZUnJcGYb.md +++ b/src/data/roadmaps/system-design/content/extraneous-fetching@6u3XmtJFWyJnyZUnJcGYb.md @@ -4,11 +4,11 @@ Extraneous fetching in system design refers to the practice of retrieving more d Extraneous fetching can lead to a number of issues, such as: -- Performance degradation -- Increased resource utilization -- Increased network traffic -- Poor user experience +* Performance degradation +* Increased resource utilization +* Increased network traffic +* Poor user experience -Visit the following links to learn more: +Visit the following resources to learn more: -- [@article@Extraneous Fetching antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/extraneous-fetching/) +- [@article@Extraneous Fetching antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/extraneous-fetching/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/fail-over@L_jRfjvMGjFbHEbozeVQl.md b/src/data/roadmaps/system-design/content/fail-over@L_jRfjvMGjFbHEbozeVQl.md index 9cab39a24..03f4b6bae 100644 --- a/src/data/roadmaps/system-design/content/fail-over@L_jRfjvMGjFbHEbozeVQl.md +++ b/src/data/roadmaps/system-design/content/fail-over@L_jRfjvMGjFbHEbozeVQl.md @@ -6,7 +6,8 @@ In a failover system, there is a primary component that is responsible for handl Failover can be implemented in various ways, such as active-passive, active-active, and hot-standby. -## Active-passive +Active-passive +-------------- With active-passive fail-over, heartbeats are sent between the active and the passive server on standby. If the heartbeat is interrupted, the passive server takes over the active's IP address and resumes service. @@ -14,7 +15,8 @@ The length of downtime is determined by whether the passive server is already ru Active-passive failover can also be referred to as master-slave failover. -## Active-active +Active-active +------------- In active-active, both servers are managing traffic, spreading the load between them. @@ -22,11 +24,12 @@ If the servers are public-facing, the DNS would need to know about the public IP Active-active failover can also be referred to as master-master failover. -## Disadvantages of Failover +Disadvantages of Failover +------------------------- -- Fail-over adds more hardware and additional complexity. -- There is a potential for loss of data if the active system fails before any newly written data can be replicated to the passive. +* Fail-over adds more hardware and additional complexity. +* There is a potential for loss of data if the active system fails before any newly written data can be replicated to the passive. -To learn more visit the following links: +Visit the following resources to learn more: -- [@article@Fail Over Pattern - High Availability](https://www.filecloud.com/blog/2015/12/architectural-patterns-for-high-availability/) +- [@article@Fail Over Pattern - High Availability](https://www.filecloud.com/blog/2015/12/architectural-patterns-for-high-availability/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/federated-identity@lHPl-kr1ArblR7bJeQEB9.md b/src/data/roadmaps/system-design/content/federated-identity@lHPl-kr1ArblR7bJeQEB9.md index 0b772578f..3c1445453 100644 --- a/src/data/roadmaps/system-design/content/federated-identity@lHPl-kr1ArblR7bJeQEB9.md +++ b/src/data/roadmaps/system-design/content/federated-identity@lHPl-kr1ArblR7bJeQEB9.md @@ -2,6 +2,6 @@ Delegate authentication to an external identity provider. This can simplify development, minimize the requirement for user administration, and improve the user experience of the application. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Federated Identity pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/federated-identity) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/federation@DGmVRI7oWdSOeIUn_g0rI.md b/src/data/roadmaps/system-design/content/federation@DGmVRI7oWdSOeIUn_g0rI.md index c48af7baf..be18017b1 100644 --- a/src/data/roadmaps/system-design/content/federation@DGmVRI7oWdSOeIUn_g0rI.md +++ b/src/data/roadmaps/system-design/content/federation@DGmVRI7oWdSOeIUn_g0rI.md @@ -1,3 +1,3 @@ # Federation -Federation (or functional partitioning) splits up databases by function. For example, instead of a single, monolithic database, you could have three databases: forums, users, and products, resulting in less read and write traffic to each database and therefore less replication lag. Smaller databases result in more data that can fit in memory, which in turn results in more cache hits due to improved cache locality. With no single central master serializing writes you can write in parallel, increasing throughput. +Federation (or functional partitioning) splits up databases by function. For example, instead of a single, monolithic database, you could have three databases: forums, users, and products, resulting in less read and write traffic to each database and therefore less replication lag. Smaller databases result in more data that can fit in memory, which in turn results in more cache hits due to improved cache locality. With no single central master serializing writes you can write in parallel, increasing throughput. \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/gatekeeper@DTQJu0AvgWOhMFcOYqzTD.md b/src/data/roadmaps/system-design/content/gatekeeper@DTQJu0AvgWOhMFcOYqzTD.md index 82aff6d88..efef34512 100644 --- a/src/data/roadmaps/system-design/content/gatekeeper@DTQJu0AvgWOhMFcOYqzTD.md +++ b/src/data/roadmaps/system-design/content/gatekeeper@DTQJu0AvgWOhMFcOYqzTD.md @@ -2,6 +2,6 @@ Protect applications and services using a dedicated host instance that acts as a broker between clients and the application or service, validates and sanitizes requests, and passes requests and data between them. This can provide an additional layer of security and limit the system's attack surface. -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Gatekeeper pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/gatekeeper) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/gateway-aggregation@bANGLm_5zR9mqMd6Oox8s.md b/src/data/roadmaps/system-design/content/gateway-aggregation@bANGLm_5zR9mqMd6Oox8s.md index 8d31865ee..70fab6447 100644 --- a/src/data/roadmaps/system-design/content/gateway-aggregation@bANGLm_5zR9mqMd6Oox8s.md +++ b/src/data/roadmaps/system-design/content/gateway-aggregation@bANGLm_5zR9mqMd6Oox8s.md @@ -2,6 +2,6 @@ Use a gateway to aggregate multiple individual requests into a single request. This pattern is useful when a client must make multiple calls to different backend systems to perform an operation. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Gateway Aggregation pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/gateway-aggregation) +- [@article@Gateway Aggregation pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/gateway-aggregation) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/gateway-offloading@0SOWAA8hrLM-WsG5k66fd.md b/src/data/roadmaps/system-design/content/gateway-offloading@0SOWAA8hrLM-WsG5k66fd.md index 732798735..d3b56f036 100644 --- a/src/data/roadmaps/system-design/content/gateway-offloading@0SOWAA8hrLM-WsG5k66fd.md +++ b/src/data/roadmaps/system-design/content/gateway-offloading@0SOWAA8hrLM-WsG5k66fd.md @@ -2,6 +2,6 @@ Offload shared or specialized service functionality to a gateway proxy. This pattern can simplify application development by moving shared service functionality, such as the use of SSL certificates, from other parts of the application into the gateway. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Gateway Offloading pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/gateway-offloading) +- [@article@Gateway Offloading pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/gateway-offloading) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/gateway-routing@LXH_mDlILqcyIKtMYTWqy.md b/src/data/roadmaps/system-design/content/gateway-routing@LXH_mDlILqcyIKtMYTWqy.md index 158337f34..a107985b0 100644 --- a/src/data/roadmaps/system-design/content/gateway-routing@LXH_mDlILqcyIKtMYTWqy.md +++ b/src/data/roadmaps/system-design/content/gateway-routing@LXH_mDlILqcyIKtMYTWqy.md @@ -2,10 +2,10 @@ Route requests to multiple services or multiple service instances using a single endpoint. The pattern is useful when you want to: -- Expose multiple services on a single endpoint and route to the appropriate service based on the request -- Expose multiple instances of the same service on a single endpoint for load balancing or availability purposes -- Expose differing versions of the same service on a single endpoint and route traffic across the different versions +* Expose multiple services on a single endpoint and route to the appropriate service based on the request +* Expose multiple instances of the same service on a single endpoint for load balancing or availability purposes +* Expose differing versions of the same service on a single endpoint and route traffic across the different versions -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Gateway Routing pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/gateway-routing) +- [@article@Gateway Routing pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/gateway-routing) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/geodes@6hOSEZJZ7yezVN67h5gmS.md b/src/data/roadmaps/system-design/content/geodes@6hOSEZJZ7yezVN67h5gmS.md index 7a4d0a157..ec07c544a 100644 --- a/src/data/roadmaps/system-design/content/geodes@6hOSEZJZ7yezVN67h5gmS.md +++ b/src/data/roadmaps/system-design/content/geodes@6hOSEZJZ7yezVN67h5gmS.md @@ -2,6 +2,6 @@ The Geode pattern involves deploying a collection of backend services into a set of geographical nodes, each of which can service any request for any client in any region. This pattern allows serving requests in an active-active style, improving latency and increasing availability by distributing request processing around the globe. -To learn more visit the following links: +Visit the following resources to learn more: -- [@article@Geode pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/geodes) +- [@article@Geode pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/geodes) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/geodes@Ml9lPDGjRAJTHkBnX51Un.md b/src/data/roadmaps/system-design/content/geodes@Ml9lPDGjRAJTHkBnX51Un.md index a82b4e78a..1c7c36bd1 100644 --- a/src/data/roadmaps/system-design/content/geodes@Ml9lPDGjRAJTHkBnX51Un.md +++ b/src/data/roadmaps/system-design/content/geodes@Ml9lPDGjRAJTHkBnX51Un.md @@ -2,7 +2,7 @@ The Geode pattern involves deploying a collection of backend services into a set of geographical nodes, each of which can service any request for any client in any region. This pattern allows serving requests in an active-active style, improving latency and increasing availability by distributing request processing around the globe. -To learn more visit the following links: +Visit the following resources to learn more: - [@article@Geode pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/geodes) - [@article@Geode Formation, Types & Appearance | What is a Geode?](https://study.com/academy/lesson/geode-formation-types-appearance.html) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/graph-databases@6RLgnL8qLBzYkllHeaI-Z.md b/src/data/roadmaps/system-design/content/graph-databases@6RLgnL8qLBzYkllHeaI-Z.md index b597d86ec..54767e0a0 100644 --- a/src/data/roadmaps/system-design/content/graph-databases@6RLgnL8qLBzYkllHeaI-Z.md +++ b/src/data/roadmaps/system-design/content/graph-databases@6RLgnL8qLBzYkllHeaI-Z.md @@ -4,8 +4,8 @@ In a graph database, each node is a record and each arc is a relationship betwee Graphs databases offer high performance for data models with complex relationships, such as a social network. They are relatively new and are not yet widely-used; it might be more difficult to find development tools and resources. Many graphs can only be accessed with REST APIs. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Graph database](https://en.wikipedia.org/wiki/Graph_database) - [@video@Introduction to NoSQL](https://www.youtube.com/watch?v=qI_g07C_Q5I) -- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh) +- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/graphql@jwv2g2Yeq-6Xv5zSd746R.md b/src/data/roadmaps/system-design/content/graphql@jwv2g2Yeq-6Xv5zSd746R.md index 5264d2f36..96ed60ce3 100644 --- a/src/data/roadmaps/system-design/content/graphql@jwv2g2Yeq-6Xv5zSd746R.md +++ b/src/data/roadmaps/system-design/content/graphql@jwv2g2Yeq-6Xv5zSd746R.md @@ -2,8 +2,8 @@ GraphQL is a query language and runtime for building APIs. It allows clients to define the structure of the data they need and the server will return exactly that. This is in contrast to traditional REST APIs, where the server exposes a fixed set of endpoints and the client must work with the data as it is returned. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@GraphQL Server](https://www.howtographql.com/basics/3-big-picture/) - [@article@What is GraphQL?](https://www.redhat.com/en/topics/api/what-is-graphql) -- [@feed@Explore top posts about GraphQL](https://app.daily.dev/tags/graphql?ref=roadmapsh) +- [@feed@Explore top posts about GraphQL](https://app.daily.dev/tags/graphql?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/grpc@Hw2v1rCYn24qxBhhmdc28.md b/src/data/roadmaps/system-design/content/grpc@Hw2v1rCYn24qxBhhmdc28.md index 386db563f..f9ca8e78b 100644 --- a/src/data/roadmaps/system-design/content/grpc@Hw2v1rCYn24qxBhhmdc28.md +++ b/src/data/roadmaps/system-design/content/grpc@Hw2v1rCYn24qxBhhmdc28.md @@ -2,7 +2,7 @@ gRPC is a high-performance, open-source framework for building remote procedure call (RPC) APIs. It is based on the Protocol Buffers data serialization format and supports a variety of programming languages, including C#, Java, and Python. -Learn more from the following links: +Visit the following resources to learn more: - [@article@What Is gRPC?](https://www.wallarm.com/what/the-concept-of-grpc) -- [@feed@Explore top posts about gRPC](https://app.daily.dev/tags/grpc?ref=roadmapsh) +- [@feed@Explore top posts about gRPC](https://app.daily.dev/tags/grpc?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/health-endpoint-monitoring@CKCNk3obx4u43rBqUj2Yf.md b/src/data/roadmaps/system-design/content/health-endpoint-monitoring@CKCNk3obx4u43rBqUj2Yf.md index 61dd01c7c..90c9440ec 100644 --- a/src/data/roadmaps/system-design/content/health-endpoint-monitoring@CKCNk3obx4u43rBqUj2Yf.md +++ b/src/data/roadmaps/system-design/content/health-endpoint-monitoring@CKCNk3obx4u43rBqUj2Yf.md @@ -2,7 +2,7 @@ Implement functional checks in an application that external tools can access through exposed endpoints at regular intervals. This can help to verify that applications and services are performing correctly. -To learn more visit the following links: +Visit the following resources to learn more: - [@article@Health Endpoint Monitoring pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/health-endpoint-monitoring) - [@article@Explaining the health endpoint monitoring pattern](https://www.oreilly.com/library/view/java-ee-8/9781788830621/5012c01e-90ca-4809-a210-d3736574f5b3.xhtml) diff --git a/src/data/roadmaps/system-design/content/health-endpoint-monitoring@cNJQoMNZmxNygWAJIA8HI.md b/src/data/roadmaps/system-design/content/health-endpoint-monitoring@cNJQoMNZmxNygWAJIA8HI.md index 61dd01c7c..90c9440ec 100644 --- a/src/data/roadmaps/system-design/content/health-endpoint-monitoring@cNJQoMNZmxNygWAJIA8HI.md +++ b/src/data/roadmaps/system-design/content/health-endpoint-monitoring@cNJQoMNZmxNygWAJIA8HI.md @@ -2,7 +2,7 @@ Implement functional checks in an application that external tools can access through exposed endpoints at regular intervals. This can help to verify that applications and services are performing correctly. -To learn more visit the following links: +Visit the following resources to learn more: - [@article@Health Endpoint Monitoring pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/health-endpoint-monitoring) - [@article@Explaining the health endpoint monitoring pattern](https://www.oreilly.com/library/view/java-ee-8/9781788830621/5012c01e-90ca-4809-a210-d3736574f5b3.xhtml) diff --git a/src/data/roadmaps/system-design/content/health-endpoint-monitoring@uK5o7NgDvr2pV0ulF0Fh9.md b/src/data/roadmaps/system-design/content/health-endpoint-monitoring@uK5o7NgDvr2pV0ulF0Fh9.md index 61dd01c7c..90c9440ec 100644 --- a/src/data/roadmaps/system-design/content/health-endpoint-monitoring@uK5o7NgDvr2pV0ulF0Fh9.md +++ b/src/data/roadmaps/system-design/content/health-endpoint-monitoring@uK5o7NgDvr2pV0ulF0Fh9.md @@ -2,7 +2,7 @@ Implement functional checks in an application that external tools can access through exposed endpoints at regular intervals. This can help to verify that applications and services are performing correctly. -To learn more visit the following links: +Visit the following resources to learn more: - [@article@Health Endpoint Monitoring pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/health-endpoint-monitoring) - [@article@Explaining the health endpoint monitoring pattern](https://www.oreilly.com/library/view/java-ee-8/9781788830621/5012c01e-90ca-4809-a210-d3736574f5b3.xhtml) diff --git a/src/data/roadmaps/system-design/content/health-monitoring@hkjYvLoVt9xKDzubm0Jy3.md b/src/data/roadmaps/system-design/content/health-monitoring@hkjYvLoVt9xKDzubm0Jy3.md index c76ddc5c4..04318fd58 100644 --- a/src/data/roadmaps/system-design/content/health-monitoring@hkjYvLoVt9xKDzubm0Jy3.md +++ b/src/data/roadmaps/system-design/content/health-monitoring@hkjYvLoVt9xKDzubm0Jy3.md @@ -2,7 +2,7 @@ A system is healthy if it is running and capable of processing requests. The purpose of health monitoring is to generate a snapshot of the current health of the system so that you can verify that all components of the system are functioning as expected. -Learn more from the following: +Visit the following resources to learn more: - [@article@Health Monitoring of a System](https://learn.microsoft.com/en-us/azure/architecture/best-practices/monitoring#health-monitoring) -- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) +- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/high-availability@wPe7Xlwqws7tEpTAVvYjr.md b/src/data/roadmaps/system-design/content/high-availability@wPe7Xlwqws7tEpTAVvYjr.md index bedd47d3a..53b41e651 100644 --- a/src/data/roadmaps/system-design/content/high-availability@wPe7Xlwqws7tEpTAVvYjr.md +++ b/src/data/roadmaps/system-design/content/high-availability@wPe7Xlwqws7tEpTAVvYjr.md @@ -2,6 +2,6 @@ Azure infrastructure is composed of geographies, regions, and Availability Zones, which limit the blast radius of a failure and therefore limit potential impact to customer applications and data. The Azure Availability Zones construct was developed to provide a software and networking solution to protect against datacenter failures and to provide increased high availability (HA) to our customers. With HA architecture there is a balance between high resilience, low latency, and cost. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@High availability Patterns](https://learn.microsoft.com/en-us/azure/architecture/framework/resiliency/reliability-patterns#high-availability) +- [@article@High availability Patterns](https://learn.microsoft.com/en-us/azure/architecture/framework/resiliency/reliability-patterns#high-availability) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/horizontal-scaling@IkUCfSWNY-02wg2WCo1c6.md b/src/data/roadmaps/system-design/content/horizontal-scaling@IkUCfSWNY-02wg2WCo1c6.md index ad0888379..37420e04b 100644 --- a/src/data/roadmaps/system-design/content/horizontal-scaling@IkUCfSWNY-02wg2WCo1c6.md +++ b/src/data/roadmaps/system-design/content/horizontal-scaling@IkUCfSWNY-02wg2WCo1c6.md @@ -2,9 +2,10 @@ Load balancers can also help with horizontal scaling, improving performance and availability. Scaling out using commodity machines is more cost efficient and results in higher availability than scaling up a single server on more expensive hardware, called Vertical Scaling. It is also easier to hire for talent working on commodity hardware than it is for specialized enterprise systems. -## Disadvantages of horizontal scaling +Disadvantages of horizontal scaling +----------------------------------- -- Scaling horizontally introduces complexity and involves cloning servers - - Servers should be stateless: they should not contain any user-related data like sessions or profile pictures - - Sessions can be stored in a centralized data store such as a database (SQL, NoSQL) or a persistent cache (Redis, Memcached) -- Downstream servers such as caches and databases need to handle more simultaneous connections as upstream servers scale out. +* Scaling horizontally introduces complexity and involves cloning servers + * Servers should be stateless: they should not contain any user-related data like sessions or profile pictures + * Sessions can be stored in a centralized data store such as a database (SQL, NoSQL) or a persistent cache (Redis, Memcached) +* Downstream servers such as caches and databases need to handle more simultaneous connections as upstream servers scale out. \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/how-to-approach-system-design@os3Pa6W9SSNEzgmlBbglQ.md b/src/data/roadmaps/system-design/content/how-to-approach-system-design@os3Pa6W9SSNEzgmlBbglQ.md index 8bda81d2e..25d333e97 100644 --- a/src/data/roadmaps/system-design/content/how-to-approach-system-design@os3Pa6W9SSNEzgmlBbglQ.md +++ b/src/data/roadmaps/system-design/content/how-to-approach-system-design@os3Pa6W9SSNEzgmlBbglQ.md @@ -2,17 +2,17 @@ There are several steps that can be taken when approaching a system design: -- **Understand the problem**: Gather information about the problem you are trying to solve and the requirements of the system. Identify the users and their needs, as well as any constraints or limitations of the system. -- **Identify the scope of the system:** Define the boundaries of the system, including what the system will do and what it will not do. -- **Research and analyze existing systems:** Look at similar systems that have been built in the past and identify what worked well and what didn't. Use this information to inform your design decisions. -- **Create a high-level design:** Outline the main components of the system and how they will interact with each other. This can include a rough diagram of the system's architecture, or a flowchart outlining the process the system will follow. -- **Refine the design:** As you work on the details of the design, iterate and refine it until you have a complete and detailed design that meets all the requirements. -- **Document the design:** Create detailed documentation of your design for future reference and maintenance. -- **Continuously monitor and improve the system:** The system design is not a one-time process, it needs to be continuously monitored and improved to meet the changing requirements. +* **Understand the problem**: Gather information about the problem you are trying to solve and the requirements of the system. Identify the users and their needs, as well as any constraints or limitations of the system. +* **Identify the scope of the system:** Define the boundaries of the system, including what the system will do and what it will not do. +* **Research and analyze existing systems:** Look at similar systems that have been built in the past and identify what worked well and what didn't. Use this information to inform your design decisions. +* **Create a high-level design:** Outline the main components of the system and how they will interact with each other. This can include a rough diagram of the system's architecture, or a flowchart outlining the process the system will follow. +* **Refine the design:** As you work on the details of the design, iterate and refine it until you have a complete and detailed design that meets all the requirements. +* **Document the design:** Create detailed documentation of your design for future reference and maintenance. +* **Continuously monitor and improve the system:** The system design is not a one-time process, it needs to be continuously monitored and improved to meet the changing requirements. -Note that this is a general approach to System Design. For interview specific answers, see the following resources: +Visit the following resources to learn more: - [@opensource@How to approach System Design?](https://github.com/donnemartin/system-design-primer#how-to-approach-a-system-design-interview-question) - [@article@What are system design questions?](https://www.hiredintech.com/system-design) -- [@video@Intro to Architecture and Systems Design Interviews](https://www.youtube.com/watch?v=ZgdS0EUmn70) - [@article@My System Design Template](https://leetcode.com/discuss/career/229177/My-System-Design-Template) +- [@video@Intro to Architecture and Systems Design Interviews](https://www.youtube.com/watch?v=ZgdS0EUmn70) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/http@I_nR6EwjNXSG7_hw-_VhX.md b/src/data/roadmaps/system-design/content/http@I_nR6EwjNXSG7_hw-_VhX.md index 355cff8d2..84c6a2a53 100644 --- a/src/data/roadmaps/system-design/content/http@I_nR6EwjNXSG7_hw-_VhX.md +++ b/src/data/roadmaps/system-design/content/http@I_nR6EwjNXSG7_hw-_VhX.md @@ -4,19 +4,16 @@ HTTP is a method for encoding and transporting data between a client and a serve A basic HTTP request consists of a verb (method) and a resource (endpoint). Below are common HTTP verbs: -``` -Verb | Description | Idempotent* | Safe | Cacheable | --------|-------------------------------|-------------|------|-----------------------------------------| -GET | Reads a resource | Yes | Yes | Yes | -POST | Creates a resource or trigger | No | No | Yes if response contains freshness info | -PUT | Creates or replace a resource | Yes | No | No | -PATCH | Partially updates a resource | No | No | Yes if response contains freshness info | -DELETE | Deletes a resource | Yes | No | No | + Verb | Description | Idempotent* | Safe | Cacheable | + -------|-------------------------------|-------------|------|-----------------------------------------| + GET | Reads a resource | Yes | Yes | Yes | + POST | Creates a resource or trigger | No | No | Yes if response contains freshness info | + PUT | Creates or replace a resource | Yes | No | No | + PATCH | Partially updates a resource | No | No | Yes if response contains freshness info | + DELETE | Deletes a resource | Yes | No | No | -``` - -HTTP is an application layer protocol relying on lower-level protocols such as TCP and UDP. +Visit the following resources to learn more: - [@article@Everything you need to know about HTTP](https://cs.fyi/guide/http-in-depth) - [@article@What Is HTTP?](https://www.nginx.com/resources/glossary/http/) -- [@article@What is the difference between HTTP protocol and TCP protocol?](https://www.quora.com/What-is-the-difference-between-HTTP-protocol-and-TCP-protocol) +- [@article@What is the difference between HTTP protocol and TCP protocol?](https://www.quora.com/What-is-the-difference-between-HTTP-protocol-and-TCP-protocol) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/idempotent-operations@3pRi8M4xQXsehkdfUNtYL.md b/src/data/roadmaps/system-design/content/idempotent-operations@3pRi8M4xQXsehkdfUNtYL.md index 76f8cba9b..c6df84364 100644 --- a/src/data/roadmaps/system-design/content/idempotent-operations@3pRi8M4xQXsehkdfUNtYL.md +++ b/src/data/roadmaps/system-design/content/idempotent-operations@3pRi8M4xQXsehkdfUNtYL.md @@ -4,7 +4,7 @@ Idempotent operations are operations that can be applied multiple times without It is also important to understand the benefits of [idempotent](https://en.wikipedia.org/wiki/Idempotence#Computer_science_meaning) operations, especially when using message or task queues that do not guarantee _exactly once_ processing. Many queueing systems guarantee _at least once_ message delivery or processing. These systems are not completely synchronized, for instance, across geographic regions, which simplifies some aspects of their implementation or design. Designing the operations that a task queue executes to be idempotent allows one to use a queueing system that has accepted this design trade-off. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@What is an idempotent operation?](https://stackoverflow.com/questions/1077412/what-is-an-idempotent-operation) -- [@article@Overview of Idempotent Operation](https://www.baeldung.com/cs/idempotent-operations) +- [@article@Overview of Idempotent Operation](https://www.baeldung.com/cs/idempotent-operations) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/improper-instantiation@lwMs4yiUHF3nQwcvauers.md b/src/data/roadmaps/system-design/content/improper-instantiation@lwMs4yiUHF3nQwcvauers.md index ee3083b28..7cfacd6b6 100644 --- a/src/data/roadmaps/system-design/content/improper-instantiation@lwMs4yiUHF3nQwcvauers.md +++ b/src/data/roadmaps/system-design/content/improper-instantiation@lwMs4yiUHF3nQwcvauers.md @@ -2,6 +2,6 @@ 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: +Visit the following resources to learn more: -- [@article@Improper Instantiation antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/improper-instantiation/) +- [@article@Improper Instantiation antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/improper-instantiation/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/index-table@AH0nVeVsfYOjcI3vZvcdz.md b/src/data/roadmaps/system-design/content/index-table@AH0nVeVsfYOjcI3vZvcdz.md index dbe5787e7..cfc979813 100644 --- a/src/data/roadmaps/system-design/content/index-table@AH0nVeVsfYOjcI3vZvcdz.md +++ b/src/data/roadmaps/system-design/content/index-table@AH0nVeVsfYOjcI3vZvcdz.md @@ -2,6 +2,6 @@ Create indexes over the fields in data stores that are frequently referenced by queries. This pattern can improve query performance by allowing applications to more quickly locate the data to retrieve from a data store. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Index Table pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/index-table) +- [@article@Index Table pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/index-table) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/instrumentation@Q0fKphqmPwjTD0dhqiP6K.md b/src/data/roadmaps/system-design/content/instrumentation@Q0fKphqmPwjTD0dhqiP6K.md index e462fe2f6..62e9a1a7c 100644 --- a/src/data/roadmaps/system-design/content/instrumentation@Q0fKphqmPwjTD0dhqiP6K.md +++ b/src/data/roadmaps/system-design/content/instrumentation@Q0fKphqmPwjTD0dhqiP6K.md @@ -2,7 +2,7 @@ Instrumentation is a critical part of the monitoring process. You can make meaningful decisions about the performance and health of a system only if you first capture the data that enables you to make these decisions. The information that you gather by using instrumentation should be sufficient to enable you to assess performance, diagnose problems, and make decisions without requiring you to sign in to a remote production server to perform tracing (and debugging) manually. Instrumentation data typically comprises metrics and information that's written to trace logs. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Instrumenting an application](https://learn.microsoft.com/en-us/azure/architecture/best-practices/monitoring#instrumenting-an-application) -- [@article@Instrumenting using Open Telemetry](https://opentelemetry.io/docs/concepts/what-is-opentelemetry) +- [@article@Instrumenting using Open Telemetry](https://opentelemetry.io/docs/concepts/what-is-opentelemetry) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/introduction@_hYN0gEi9BL24nptEtXWU.md b/src/data/roadmaps/system-design/content/introduction@_hYN0gEi9BL24nptEtXWU.md index 4f8555828..2d99ce873 100644 --- a/src/data/roadmaps/system-design/content/introduction@_hYN0gEi9BL24nptEtXWU.md +++ b/src/data/roadmaps/system-design/content/introduction@_hYN0gEi9BL24nptEtXWU.md @@ -6,4 +6,4 @@ It involves taking a problem statement, breaking it down into smaller components In software engineering, system design is a phase in the software development process that focuses on the high-level design of a software system, including the architecture and components. -It is also one of the important aspects of the interview process for software engineers. Most of the companies have a dedicated system design interview round, where they ask the candidates to design a system for a given problem statement. The candidates are expected to come up with a detailed design of the system, including the architecture, components, and their interactions. They are also expected to discuss the trade-offs involved in their design and the alternatives that they considered. +It is also one of the important aspects of the interview process for software engineers. Most of the companies have a dedicated system design interview round, where they ask the candidates to design a system for a given problem statement. The candidates are expected to come up with a detailed design of the system, including the architecture, components, and their interactions. They are also expected to discuss the trade-offs involved in their design and the alternatives that they considered. \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/key-value-store@KFtdmmce4bRkDyvFXZzLN.md b/src/data/roadmaps/system-design/content/key-value-store@KFtdmmce4bRkDyvFXZzLN.md index e0217f246..eb48d378b 100644 --- a/src/data/roadmaps/system-design/content/key-value-store@KFtdmmce4bRkDyvFXZzLN.md +++ b/src/data/roadmaps/system-design/content/key-value-store@KFtdmmce4bRkDyvFXZzLN.md @@ -4,7 +4,7 @@ A key-value store generally allows for `O(1)` reads and writes and is often back Key-value stores provide high performance and are often used for simple data models or for rapidly-changing data, such as an in-memory cache layer. Since they offer only a limited set of operations, complexity is shifted to the application layer if additional operations are needed. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Key–value database](https://en.wikipedia.org/wiki/Key%E2%80%93value_database) -- [@article@What are the disadvantages of using a key/value table?](https://stackoverflow.com/questions/4056093/what-are-the-disadvantages-of-using-a-key-value-table-over-nullable-columns-or) +- [@article@What are the disadvantages of using a key/value table?](https://stackoverflow.com/questions/4056093/what-are-the-disadvantages-of-using-a-key-value-table-over-nullable-columns-or) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/latency-vs-throughput@O3wAHLnzrkvLWr4afHDdr.md b/src/data/roadmaps/system-design/content/latency-vs-throughput@O3wAHLnzrkvLWr4afHDdr.md index 422d7e1b5..78414e2ab 100644 --- a/src/data/roadmaps/system-design/content/latency-vs-throughput@O3wAHLnzrkvLWr4afHDdr.md +++ b/src/data/roadmaps/system-design/content/latency-vs-throughput@O3wAHLnzrkvLWr4afHDdr.md @@ -4,7 +4,7 @@ Latency and throughput are two important measures of a system's performance. **L Generally, you should aim for maximal throughput with acceptable latency. -Learn more from the following links: +Visit the following resources to learn more: - [@article@System Design: Latency vs Throughput](https://cs.fyi/guide/latency-vs-throughput/) - [@article@Understanding Latency versus Throughput](https://community.cadence.com/cadence_blogs_8/b/fv/posts/understanding-latency-vs-throughput) diff --git a/src/data/roadmaps/system-design/content/layer-4-load-balancing@MpM9rT1-_LGD7YbnBjqOk.md b/src/data/roadmaps/system-design/content/layer-4-load-balancing@MpM9rT1-_LGD7YbnBjqOk.md index 6fa60635d..07cc8d72a 100644 --- a/src/data/roadmaps/system-design/content/layer-4-load-balancing@MpM9rT1-_LGD7YbnBjqOk.md +++ b/src/data/roadmaps/system-design/content/layer-4-load-balancing@MpM9rT1-_LGD7YbnBjqOk.md @@ -2,6 +2,6 @@ Layer 4 load balancers look at info at the transport layer to decide how to distribute requests. Generally, this involves the source, destination IP addresses, and ports in the header, but not the contents of the packet. Layer 4 load balancers forward network packets to and from the upstream server, performing Network Address Translation (NAT). -Learn more from the following links: +Visit the following resources to learn more: - [@article@Layer 4 Load Balancing](https://www.f5.com/glossary/layer-4-load-balancing) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/layer-7-load-balancing@e69-JVbDj7dqV_p1j1kML.md b/src/data/roadmaps/system-design/content/layer-7-load-balancing@e69-JVbDj7dqV_p1j1kML.md index 5c93340b6..ccd4676c7 100644 --- a/src/data/roadmaps/system-design/content/layer-7-load-balancing@e69-JVbDj7dqV_p1j1kML.md +++ b/src/data/roadmaps/system-design/content/layer-7-load-balancing@e69-JVbDj7dqV_p1j1kML.md @@ -2,4 +2,4 @@ Layer 7 load balancers look at the application layer to decide how to distribute requests. This can involve contents of the header, message, and cookies. Layer 7 load balancers terminate network traffic, reads the message, makes a load-balancing decision, then opens a connection to the selected server. For example, a layer 7 load balancer can direct video traffic to servers that host videos while directing more sensitive user billing traffic to security-hardened servers. -At the cost of flexibility, layer 4 load balancing requires less time and computing resources than Layer 7, although the performance impact can be minimal on modern commodity hardware. +At the cost of flexibility, layer 4 load balancing requires less time and computing resources than Layer 7, although the performance impact can be minimal on modern commodity hardware. \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/lb-vs-reverse-proxy@ocdcbhHrwjJX0KWgmsOL6.md b/src/data/roadmaps/system-design/content/lb-vs-reverse-proxy@ocdcbhHrwjJX0KWgmsOL6.md index bd2ee0758..d4d74d772 100644 --- a/src/data/roadmaps/system-design/content/lb-vs-reverse-proxy@ocdcbhHrwjJX0KWgmsOL6.md +++ b/src/data/roadmaps/system-design/content/lb-vs-reverse-proxy@ocdcbhHrwjJX0KWgmsOL6.md @@ -1,17 +1,18 @@ # Load Balancer vs Reverse Proxy -- Deploying a load balancer is useful when you have multiple servers. Often, load balancers route traffic to a set of servers serving the same function. -- Reverse proxies can be useful even with just one web server or application server, opening up the benefits described in the previous section. -- Solutions such as NGINX and HAProxy can support both layer 7 reverse proxying and load balancing. +* Deploying a load balancer is useful when you have multiple servers. Often, load balancers route traffic to a set of servers serving the same function. +* Reverse proxies can be useful even with just one web server or application server, opening up the benefits described in the previous section. +* Solutions such as NGINX and HAProxy can support both layer 7 reverse proxying and load balancing. -## Disadvantages of Reverse Proxy: +Disadvantages of Reverse Proxy: +------------------------------- -- Introducing a reverse proxy results in increased complexity. -- A single reverse proxy is a single point of failure, configuring multiple reverse proxies (ie a failover) further increases complexity. +* Introducing a reverse proxy results in increased complexity. +* A single reverse proxy is a single point of failure, configuring multiple reverse proxies (ie a failover) further increases complexity. -To learn more visit the following links: +Visit the following resources to learn more: - [@article@Reverse Proxy vs Load Balancer](https://www.nginx.com/resources/glossary/reverse-proxy-vs-load-balancer/) - [@article@NGINX Architecture](https://www.nginx.com/blog/inside-nginx-how-we-designed-for-performance-scale/) - [@article@HAProxy Architecture Guide](http://www.haproxy.org/download/1.2/doc/architecture.txt) -- [@article@Reverse Proxy](https://en.wikipedia.org/wiki/Reverse_proxy) +- [@article@Reverse Proxy](https://en.wikipedia.org/wiki/Reverse_proxy) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/leader-election@AJLBFyAsEdQYF6ygO0MmQ.md b/src/data/roadmaps/system-design/content/leader-election@AJLBFyAsEdQYF6ygO0MmQ.md index 885cc1020..a79e2f0a2 100644 --- a/src/data/roadmaps/system-design/content/leader-election@AJLBFyAsEdQYF6ygO0MmQ.md +++ b/src/data/roadmaps/system-design/content/leader-election@AJLBFyAsEdQYF6ygO0MmQ.md @@ -2,6 +2,6 @@ Coordinate the actions performed by a collection of collaborating instances in a distributed application by electing one instance as the leader that assumes responsibility for managing the others. This can help to ensure that instances don't conflict with each other, cause contention for shared resources, or inadvertently interfere with the work that other instances are performing. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Leader Election Pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/leader-election) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/leader-election@beWKUIB6Za27yhxQwEYe3.md b/src/data/roadmaps/system-design/content/leader-election@beWKUIB6Za27yhxQwEYe3.md index 885cc1020..a79e2f0a2 100644 --- a/src/data/roadmaps/system-design/content/leader-election@beWKUIB6Za27yhxQwEYe3.md +++ b/src/data/roadmaps/system-design/content/leader-election@beWKUIB6Za27yhxQwEYe3.md @@ -2,6 +2,6 @@ Coordinate the actions performed by a collection of collaborating instances in a distributed application by electing one instance as the leader that assumes responsibility for managing the others. This can help to ensure that instances don't conflict with each other, cause contention for shared resources, or inadvertently interfere with the work that other instances are performing. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Leader Election Pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/leader-election) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/load-balancers@14KqLKgh090Rb3MDwelWY.md b/src/data/roadmaps/system-design/content/load-balancers@14KqLKgh090Rb3MDwelWY.md index 86214563f..a0cf71daf 100644 --- a/src/data/roadmaps/system-design/content/load-balancers@14KqLKgh090Rb3MDwelWY.md +++ b/src/data/roadmaps/system-design/content/load-balancers@14KqLKgh090Rb3MDwelWY.md @@ -2,24 +2,25 @@ Load balancers distribute incoming client requests to computing resources such as application servers and databases. In each case, the load balancer returns the response from the computing resource to the appropriate client. Load balancers are effective at: -- Preventing requests from going to unhealthy servers -- Preventing overloading resources -- Helping to eliminate a single point of failure +* Preventing requests from going to unhealthy servers +* Preventing overloading resources +* Helping to eliminate a single point of failure Load balancers can be implemented with hardware (expensive) or with software such as HAProxy. Additional benefits include: -- **SSL termination** - Decrypt incoming requests and encrypt server responses so backend servers do not have to perform these potentially expensive operations - - Removes the need to install X.509 certificates on each server -- **Session persistence** - Issue cookies and route a specific client's requests to same instance if the web apps do not keep track of sessions +* **SSL termination** - Decrypt incoming requests and encrypt server responses so backend servers do not have to perform these potentially expensive operations + * Removes the need to install X.509 certificates on each server +* **Session persistence** - Issue cookies and route a specific client's requests to same instance if the web apps do not keep track of sessions -## Disadvantages of load balancer +Disadvantages of load balancer +------------------------------ -- The load balancer can become a performance bottleneck if it does not have enough resources or if it is not configured properly. -- Introducing a load balancer to help eliminate a single point of failure results in increased complexity. -- A single load balancer is a single point of failure, configuring multiple load balancers further increases complexity. +* The load balancer can become a performance bottleneck if it does not have enough resources or if it is not configured properly. +* Introducing a load balancer to help eliminate a single point of failure results in increased complexity. +* A single load balancer is a single point of failure, configuring multiple load balancers further increases complexity. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Scalability](https://cs.fyi/guide/scalability-for-dummies) - [@article@NGINX Architecture](https://www.nginx.com/blog/inside-nginx-how-we-designed-for-performance-scale/) -- [@article@HAProxy Architecture Guide](http://www.haproxy.org/download/1.2/doc/architecture.txt) +- [@article@HAProxy Architecture Guide](http://www.haproxy.org/download/1.2/doc/architecture.txt) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/load-balancing-algorithms@urSjLyLTE5IIz0TFxMBWL.md b/src/data/roadmaps/system-design/content/load-balancing-algorithms@urSjLyLTE5IIz0TFxMBWL.md index 149dddd64..82638963e 100644 --- a/src/data/roadmaps/system-design/content/load-balancing-algorithms@urSjLyLTE5IIz0TFxMBWL.md +++ b/src/data/roadmaps/system-design/content/load-balancing-algorithms@urSjLyLTE5IIz0TFxMBWL.md @@ -4,7 +4,7 @@ A load balancer is a software or hardware device that keeps any one server from There are two primary approaches to load balancing. Dynamic load balancing uses algorithms that take into account the current state of each server and distribute traffic accordingly. Static load balancing distributes traffic without making these adjustments. Some static algorithms send an equal amount of traffic to each server in a group, either in a specified order or at random. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Types of Load Balancing Algorithms](https://www.cloudflare.com/learning/performance/types-of-load-balancing-algorithms/) -- [@feed@Explore top posts about Algorithms](https://app.daily.dev/tags/algorithms?ref=roadmapsh) +- [@feed@Explore top posts about Algorithms](https://app.daily.dev/tags/algorithms?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/materialized-view@WB7vQ4IJ0TPh2MbZvxP6V.md b/src/data/roadmaps/system-design/content/materialized-view@WB7vQ4IJ0TPh2MbZvxP6V.md index 2732b0295..08c9b40f4 100644 --- a/src/data/roadmaps/system-design/content/materialized-view@WB7vQ4IJ0TPh2MbZvxP6V.md +++ b/src/data/roadmaps/system-design/content/materialized-view@WB7vQ4IJ0TPh2MbZvxP6V.md @@ -2,6 +2,6 @@ Generate prepopulated views over the data in one or more data stores when the data isn't ideally formatted for required query operations. This can help support efficient querying and data extraction, and improve application performance. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Materialized View pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/materialized-view) +- [@article@Materialized View pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/materialized-view) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/message-queues@37X1_9eCmkZkz5RDudE5N.md b/src/data/roadmaps/system-design/content/message-queues@37X1_9eCmkZkz5RDudE5N.md index c835a243f..1c94497c3 100644 --- a/src/data/roadmaps/system-design/content/message-queues@37X1_9eCmkZkz5RDudE5N.md +++ b/src/data/roadmaps/system-design/content/message-queues@37X1_9eCmkZkz5RDudE5N.md @@ -2,17 +2,17 @@ Message queues receive, hold, and deliver messages. If an operation is too slow to perform inline, you can use a message queue with the following workflow: -- An application publishes a job to the queue, then notifies the user of job status -- A worker picks up the job from the queue, processes it, then signals the job is complete +* An application publishes a job to the queue, then notifies the user of job status +* A worker picks up the job from the queue, processes it, then signals the job is complete The user is not blocked and the job is processed in the background. During this time, the client might optionally do a small amount of processing to make it seem like the task has completed. For example, if posting a tweet, the tweet could be instantly posted to your timeline, but it could take some time before your tweet is actually delivered to all of your followers. -- [@article@Redis](https://redis.io/) is useful as a simple message broker but messages can be lost. -- [@article@RabbitMQ](https://www.rabbitmq.com/) is popular but requires you to adapt to the 'AMQP' protocol and manage your own nodes. -- [@article@AWS SQS](https://aws.amazon.com/sqs/) is hosted but can have high latency and has the possibility of messages being delivered twice. -- [@article@Apache Kafka](https://kafka.apache.org/) is a distributed event store and stream-processing platform. +* [@article@Redis](https://redis.io/) is useful as a simple message broker but messages can be lost. +* [@article@RabbitMQ](https://www.rabbitmq.com/) is popular but requires you to adapt to the 'AMQP' protocol and manage your own nodes. +* [@article@AWS SQS](https://aws.amazon.com/sqs/) is hosted but can have high latency and has the possibility of messages being delivered twice. +* [@article@Apache Kafka](https://kafka.apache.org/) is a distributed event store and stream-processing platform. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@What is Redis?](https://redis.io/) - [@article@RabbitMQ in Message Queues](https://www.rabbitmq.com/) diff --git a/src/data/roadmaps/system-design/content/messaging@dsWpta3WIBvv2K9pNVPo0.md b/src/data/roadmaps/system-design/content/messaging@dsWpta3WIBvv2K9pNVPo0.md index 000cd8269..36d61b0e0 100644 --- a/src/data/roadmaps/system-design/content/messaging@dsWpta3WIBvv2K9pNVPo0.md +++ b/src/data/roadmaps/system-design/content/messaging@dsWpta3WIBvv2K9pNVPo0.md @@ -2,6 +2,6 @@ Messaging is a pattern that allows for the communication and coordination between different components or systems, using messaging technologies such as message queues, message brokers, and event buses. This pattern allows for decoupling of the sender and receiver, and can be used to build scalable and flexible systems. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Messaging Cloud Patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/category/messaging) +- [@article@Messaging Cloud Patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/category/messaging) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/microservices@UKTiaHCzYXnrNw31lHriv.md b/src/data/roadmaps/system-design/content/microservices@UKTiaHCzYXnrNw31lHriv.md index 6b769316c..442a153f4 100644 --- a/src/data/roadmaps/system-design/content/microservices@UKTiaHCzYXnrNw31lHriv.md +++ b/src/data/roadmaps/system-design/content/microservices@UKTiaHCzYXnrNw31lHriv.md @@ -4,9 +4,9 @@ Related to the "Application Layer" discussion are microservices, which can be de Pinterest, for example, could have the following microservices: user profile, follower, feed, search, photo upload, etc. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Introduction to Microservices](https://aws.amazon.com/microservices/) - [@article@Microservices - Wikipedia](https://en.wikipedia.org/wiki/Microservices) - [@article@Microservices](https://martinfowler.com/articles/microservices.html) -- [@feed@Explore top posts about Microservices](https://app.daily.dev/tags/microservices?ref=roadmapsh) +- [@feed@Explore top posts about Microservices](https://app.daily.dev/tags/microservices?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/monitoring@hDFYlGFYwcwWXLmrxodFX.md b/src/data/roadmaps/system-design/content/monitoring@hDFYlGFYwcwWXLmrxodFX.md index 8fea70803..a546f266a 100644 --- a/src/data/roadmaps/system-design/content/monitoring@hDFYlGFYwcwWXLmrxodFX.md +++ b/src/data/roadmaps/system-design/content/monitoring@hDFYlGFYwcwWXLmrxodFX.md @@ -2,7 +2,7 @@ Distributed applications and services running in the cloud are, by their nature, complex pieces of software that comprise many moving parts. In a production environment, it's important to be able to track the way in which users use your system, trace resource utilization, and generally monitor the health and performance of your system. You can use this information as a diagnostic aid to detect and correct issues, and also to help spot potential problems and prevent them from occurring. -Visit the following to learn more: +Visit the following resources to learn more: - [@article@Monitoring and Diagnostics Guidance](https://learn.microsoft.com/en-us/azure/architecture/best-practices/monitoring) -- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) +- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/monolithic-persistence@p1QhCptnwzTGUXVMnz_Oz.md b/src/data/roadmaps/system-design/content/monolithic-persistence@p1QhCptnwzTGUXVMnz_Oz.md index 76817e1f5..1c2d25001 100644 --- a/src/data/roadmaps/system-design/content/monolithic-persistence@p1QhCptnwzTGUXVMnz_Oz.md +++ b/src/data/roadmaps/system-design/content/monolithic-persistence@p1QhCptnwzTGUXVMnz_Oz.md @@ -2,6 +2,6 @@ Monolithic Persistence 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: +Visit the following resources to learn more: -- [@article@Monolithic Persistence antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/monolithic-persistence/) +- [@article@Monolithic Persistence antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/monolithic-persistence/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/no-caching@klvHk1_e03Jarn5T46QNi.md b/src/data/roadmaps/system-design/content/no-caching@klvHk1_e03Jarn5T46QNi.md index 6ae1d24ac..858844927 100644 --- a/src/data/roadmaps/system-design/content/no-caching@klvHk1_e03Jarn5T46QNi.md +++ b/src/data/roadmaps/system-design/content/no-caching@klvHk1_e03Jarn5T46QNi.md @@ -4,10 +4,10 @@ No caching antipattern occurs when a cloud application that handles many concurr When data is not cached, it can cause a number of undesirable behaviors, including: -- Repeatedly fetching the same information from a resource that is expensive to access, in terms of I/O overhead or latency. -- Repeatedly constructing the same objects or data structures for multiple requests. -- Making excessive calls to a remote service that has a service quota and throttles clients past a certain limit. +* Repeatedly fetching the same information from a resource that is expensive to access, in terms of I/O overhead or latency. +* Repeatedly constructing the same objects or data structures for multiple requests. +* Making excessive calls to a remote service that has a service quota and throttles clients past a certain limit. -In turn, these problems can lead to poor response times, increased contention in the data store, and poor scalability. +Visit the following resources to learn more: -- [@article@No Caching antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/no-caching/) +- [@article@No Caching antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/no-caching/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/noisy-neighbor@r7uQxmurvfsYtTCieHqly.md b/src/data/roadmaps/system-design/content/noisy-neighbor@r7uQxmurvfsYtTCieHqly.md index a0a29eabd..920dc881b 100644 --- a/src/data/roadmaps/system-design/content/noisy-neighbor@r7uQxmurvfsYtTCieHqly.md +++ b/src/data/roadmaps/system-design/content/noisy-neighbor@r7uQxmurvfsYtTCieHqly.md @@ -4,10 +4,10 @@ Noisy neighbor refers to a situation in which one or more components of a system 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. +* 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: +Visit the following resources to learn more: -- [@article@Noisy Neighbor antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/noisy-neighbor/noisy-neighbor) +- [@article@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/data/roadmaps/system-design/content/performance-antipatterns@p--uEm6klLx_hKxKJiXE5.md b/src/data/roadmaps/system-design/content/performance-antipatterns@p--uEm6klLx_hKxKJiXE5.md index 8d300907c..afbd3a0c5 100644 --- a/src/data/roadmaps/system-design/content/performance-antipatterns@p--uEm6klLx_hKxKJiXE5.md +++ b/src/data/roadmaps/system-design/content/performance-antipatterns@p--uEm6klLx_hKxKJiXE5.md @@ -4,12 +4,12 @@ Performance antipatterns in system design refer to common mistakes or suboptimal Some of the 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. +* **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: +Visit the following resources to learn more: - [@article@Performance antipatterns for cloud applications](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/) -- [@feed@Explore top posts about Performance](https://app.daily.dev/tags/performance?ref=roadmapsh) +- [@feed@Explore top posts about Performance](https://app.daily.dev/tags/performance?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/performance-monitoring@x1i3qWFtNNjd00-kAvFHw.md b/src/data/roadmaps/system-design/content/performance-monitoring@x1i3qWFtNNjd00-kAvFHw.md index ea39352f3..98e03f16d 100644 --- a/src/data/roadmaps/system-design/content/performance-monitoring@x1i3qWFtNNjd00-kAvFHw.md +++ b/src/data/roadmaps/system-design/content/performance-monitoring@x1i3qWFtNNjd00-kAvFHw.md @@ -2,7 +2,7 @@ As the system is placed under more and more stress (by increasing the volume of users), the size of the datasets that these users access grows and the possibility of failure of one or more components becomes more likely. Frequently, component failure is preceded by a decrease in performance. If you're able detect such a decrease, you can take proactive steps to remedy the situation. -Learn more from following links: +Visit the following resources to learn more: - [@article@Performance Monitoring](https://learn.microsoft.com/en-us/azure/architecture/best-practices/monitoring#performance-monitoring) -- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) +- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/performance-vs-scalability@e_15lymUjFc6VWqzPnKxG.md b/src/data/roadmaps/system-design/content/performance-vs-scalability@e_15lymUjFc6VWqzPnKxG.md index d92e2aefc..0f8a96d30 100644 --- a/src/data/roadmaps/system-design/content/performance-vs-scalability@e_15lymUjFc6VWqzPnKxG.md +++ b/src/data/roadmaps/system-design/content/performance-vs-scalability@e_15lymUjFc6VWqzPnKxG.md @@ -4,12 +4,12 @@ A service is **scalable** if it results in increased **performance** in a manner Another way to look at performance vs scalability: -- If you have a **performance** problem, your system is slow for a single user. -- If you have a **scalability** problem, your system is fast for a single user but slow under heavy load. +* If you have a **performance** problem, your system is slow for a single user. +* If you have a **scalability** problem, your system is fast for a single user but slow under heavy load. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Scalability, Availability & Stability Patterns](https://www.slideshare.net/jboner/scalability-availability-stability-patterns/) - [@article@A Word on Scalability](https://www.allthingsdistributed.com/2006/03/a_word_on_scalability.html) - [@article@Performance vs Scalability](https://blog.professorbeekums.com/performance-vs-scalability/) -- [@feed@Explore top posts about Performance](https://app.daily.dev/tags/performance?ref=roadmapsh) +- [@feed@Explore top posts about Performance](https://app.daily.dev/tags/performance?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/pipes--filters@WkoFezOXLf1H2XI9AtBtv.md b/src/data/roadmaps/system-design/content/pipes--filters@WkoFezOXLf1H2XI9AtBtv.md index a59b0a17f..07cfcc05d 100644 --- a/src/data/roadmaps/system-design/content/pipes--filters@WkoFezOXLf1H2XI9AtBtv.md +++ b/src/data/roadmaps/system-design/content/pipes--filters@WkoFezOXLf1H2XI9AtBtv.md @@ -2,6 +2,6 @@ Decompose a task that performs complex processing into a series of separate elements that can be reused. This can improve performance, scalability, and reusability by allowing task elements that perform the processing to be deployed and scaled independently. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Pipe and Filter Architectural Style](https://learn.microsoft.com/en-us/azure/architecture/patterns/pipes-and-filters) +- [@article@Pipe and Filter Architectural Style](https://learn.microsoft.com/en-us/azure/architecture/patterns/pipes-and-filters) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/pipes-and-filters@siXdR3TB9-4wx_qWieJ5w.md b/src/data/roadmaps/system-design/content/pipes-and-filters@siXdR3TB9-4wx_qWieJ5w.md index eb08d9349..bd7135818 100644 --- a/src/data/roadmaps/system-design/content/pipes-and-filters@siXdR3TB9-4wx_qWieJ5w.md +++ b/src/data/roadmaps/system-design/content/pipes-and-filters@siXdR3TB9-4wx_qWieJ5w.md @@ -2,6 +2,6 @@ Decompose a task that performs complex processing into a series of separate elements that can be reused. This can improve performance, scalability, and reusability by allowing task elements that perform the processing to be deployed and scaled independently. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Pipes and Filters pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/pipes-and-filters) +- [@article@Pipes and Filters pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/pipes-and-filters) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/priority-queue@DZcZEOi7h3u0744YhASet.md b/src/data/roadmaps/system-design/content/priority-queue@DZcZEOi7h3u0744YhASet.md index df8a5332d..701051505 100644 --- a/src/data/roadmaps/system-design/content/priority-queue@DZcZEOi7h3u0744YhASet.md +++ b/src/data/roadmaps/system-design/content/priority-queue@DZcZEOi7h3u0744YhASet.md @@ -2,6 +2,6 @@ Prioritize requests sent to services so that requests with a higher priority are received and processed more quickly than those with a lower priority. This pattern is useful in applications that offer different service level guarantees to individual clients. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Priority Queue pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/priority-queue) +- [@article@Priority Queue pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/priority-queue) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/publishersubscriber@2ryzJhRDTo98gGgn9mAxR.md b/src/data/roadmaps/system-design/content/publishersubscriber@2ryzJhRDTo98gGgn9mAxR.md index 4f619d2fe..e8fc5c32e 100644 --- a/src/data/roadmaps/system-design/content/publishersubscriber@2ryzJhRDTo98gGgn9mAxR.md +++ b/src/data/roadmaps/system-design/content/publishersubscriber@2ryzJhRDTo98gGgn9mAxR.md @@ -2,6 +2,6 @@ Enable an application to announce events to multiple interested consumers asynchronously, without coupling the senders to the receivers. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Publisher-Subscriber pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/publisher-subscriber) +- [@article@Publisher-Subscriber pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/publisher-subscriber) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/pull-cdns@HkXiEMLqxJoQyAHav3ccL.md b/src/data/roadmaps/system-design/content/pull-cdns@HkXiEMLqxJoQyAHav3ccL.md index 61923912c..3ef535690 100644 --- a/src/data/roadmaps/system-design/content/pull-cdns@HkXiEMLqxJoQyAHav3ccL.md +++ b/src/data/roadmaps/system-design/content/pull-cdns@HkXiEMLqxJoQyAHav3ccL.md @@ -4,7 +4,7 @@ Pull CDNs grab new content from your server when the first user requests the con A time-to-live (TTL) determines how long content is cached. Pull CDNs minimize storage space on the CDN, but can create redundant traffic if files expire and are pulled before they have actually changed. Sites with heavy traffic work well with pull CDNs, as traffic is spread out more evenly with only recently-requested content remaining on the CDN. -To learn more, visit the following links: +Visit the following resources to learn more: - [@opensource@Introduction to CDNs](https://github.com/donnemartin/system-design-primer#content-delivery-network) -- [@article@The Differences Between Push And Pull CDNs](http://www.travelblogadvice.com/technical/the-differences-between-push-and-pull-cdns/) +- [@article@The Differences Between Push And Pull CDNs](http://www.travelblogadvice.com/technical/the-differences-between-push-and-pull-cdns/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/push-cdns@uIerrf_oziiLg-KEyz8WM.md b/src/data/roadmaps/system-design/content/push-cdns@uIerrf_oziiLg-KEyz8WM.md index e4bbc376f..f223c7b58 100644 --- a/src/data/roadmaps/system-design/content/push-cdns@uIerrf_oziiLg-KEyz8WM.md +++ b/src/data/roadmaps/system-design/content/push-cdns@uIerrf_oziiLg-KEyz8WM.md @@ -4,6 +4,6 @@ Push CDNs receive new content whenever changes occur on your server. You take fu Sites with a small amount of traffic or sites with content that isn't often updated work well with push CDNs. Content is placed on the CDNs once, instead of being re-pulled at regular intervals. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@opensource@Introduction to CDNs](https://github.com/donnemartin/system-design-primer#content-delivery-network) +- [@opensource@Introduction to CDNs](https://github.com/donnemartin/system-design-primer#content-delivery-network) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/queu-based-load-leveling@LncTxPg-wx8loy55r5NmV.md b/src/data/roadmaps/system-design/content/queu-based-load-leveling@LncTxPg-wx8loy55r5NmV.md new file mode 100644 index 000000000..c0b543f05 --- /dev/null +++ b/src/data/roadmaps/system-design/content/queu-based-load-leveling@LncTxPg-wx8loy55r5NmV.md @@ -0,0 +1,7 @@ +# Queue-Based Load Leveling + +Use a queue that acts as a buffer between a task and a service it invokes in order to smooth intermittent heavy loads that can cause the service to fail or the task to time out. This can help to minimize the impact of peaks in demand on availability and responsiveness for both the task and the service. + +Visit the following resources to learn more: + +- [@article@Queue-Based Load Leveling pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/queue-based-load-leveling) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/queue-based-load-leveling@-M3Zd8w79sKBAY6_aJRE8.md b/src/data/roadmaps/system-design/content/queue-based-load-leveling@-M3Zd8w79sKBAY6_aJRE8.md index 1aefa3c1e..dbb15aee6 100644 --- a/src/data/roadmaps/system-design/content/queue-based-load-leveling@-M3Zd8w79sKBAY6_aJRE8.md +++ b/src/data/roadmaps/system-design/content/queue-based-load-leveling@-M3Zd8w79sKBAY6_aJRE8.md @@ -2,6 +2,6 @@ Use a queue that acts as a buffer between a task and a service it invokes in order to smooth intermittent heavy loads that can cause the service to fail or the task to time out. This can help to minimize the impact of peaks in demand on availability and responsiveness for both the task and the service. -To learn more visit the following links: +Visit the following resources to learn more: - [@article@Queue-Based Load Leveling pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/queue-based-load-leveling) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/queue-based-load-leveling@NybkOwl1lgaglZPRJQJ_Z.md b/src/data/roadmaps/system-design/content/queue-based-load-leveling@NybkOwl1lgaglZPRJQJ_Z.md index 1aefa3c1e..dbb15aee6 100644 --- a/src/data/roadmaps/system-design/content/queue-based-load-leveling@NybkOwl1lgaglZPRJQJ_Z.md +++ b/src/data/roadmaps/system-design/content/queue-based-load-leveling@NybkOwl1lgaglZPRJQJ_Z.md @@ -2,6 +2,6 @@ Use a queue that acts as a buffer between a task and a service it invokes in order to smooth intermittent heavy loads that can cause the service to fail or the task to time out. This can help to minimize the impact of peaks in demand on availability and responsiveness for both the task and the service. -To learn more visit the following links: +Visit the following resources to learn more: - [@article@Queue-Based Load Leveling pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/queue-based-load-leveling) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/refresh-ahead@Bgqgl67FK56ioLNFivIsc.md b/src/data/roadmaps/system-design/content/refresh-ahead@Bgqgl67FK56ioLNFivIsc.md index c80b1d31e..29e3312e1 100644 --- a/src/data/roadmaps/system-design/content/refresh-ahead@Bgqgl67FK56ioLNFivIsc.md +++ b/src/data/roadmaps/system-design/content/refresh-ahead@Bgqgl67FK56ioLNFivIsc.md @@ -4,12 +4,13 @@ You can configure the cache to automatically refresh any recently accessed cache Refresh-ahead can result in reduced latency vs read-through if the cache can accurately predict which items are likely to be needed in the future. -## Disadvantage of refresh-ahead: +Disadvantage of refresh-ahead: +------------------------------ -- Not accurately predicting which items are likely to be needed in the future can result in reduced performance than without refresh-ahead. +* Not accurately predicting which items are likely to be needed in the future can result in reduced performance than without refresh-ahead. ![](https://i.imgur.com/sBXb7lb.png) -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@From cache to in-memory data grid](http://www.slideshare.net/tmatyashovsky/from-cache-to-in-memory-data-grid-introduction-to-hazelcast) +- [@article@From cache to in-memory data grid](http://www.slideshare.net/tmatyashovsky/from-cache-to-in-memory-data-grid-introduction-to-hazelcast) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/reliability-patterns@DYkdM_L7T2GcTPAoZNnUR.md b/src/data/roadmaps/system-design/content/reliability-patterns@DYkdM_L7T2GcTPAoZNnUR.md index 25ea5ce24..c7350078a 100644 --- a/src/data/roadmaps/system-design/content/reliability-patterns@DYkdM_L7T2GcTPAoZNnUR.md +++ b/src/data/roadmaps/system-design/content/reliability-patterns@DYkdM_L7T2GcTPAoZNnUR.md @@ -2,6 +2,6 @@ These patterns provide a way to design and implement systems that can withstand failures, maintain high levels of performance, and recover quickly from disruptions. Some common reliability patterns include Failover, Circuit Breaker, Retry, Bulkhead, Backpressure, Cache-Aside, Idempotent Operations and Health Endpoint Monitoring. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Reliability Patterns](https://learn.microsoft.com/en-us/azure/architecture/framework/resiliency/reliability-patterns) +- [@article@Reliability Patterns](https://learn.microsoft.com/en-us/azure/architecture/framework/resiliency/reliability-patterns) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/replication@0RQ5jzZKdadYY0h_QZ0Bb.md b/src/data/roadmaps/system-design/content/replication@0RQ5jzZKdadYY0h_QZ0Bb.md index 8fe38092e..7eff3d7be 100644 --- a/src/data/roadmaps/system-design/content/replication@0RQ5jzZKdadYY0h_QZ0Bb.md +++ b/src/data/roadmaps/system-design/content/replication@0RQ5jzZKdadYY0h_QZ0Bb.md @@ -2,10 +2,10 @@ Replication is an availability pattern that involves having multiple copies of the same data stored in different locations. In the event of a failure, the data can be retrieved from a different location. There are two main types of replication: Master-Master replication and Master-Slave replication. -- **Master-Master replication:** In this type of replication, multiple servers are configured as "masters," and each one can accept read and write operations. This allows for high availability and allows any of the servers to take over if one of them fails. However, this type of replication can lead to conflicts if multiple servers update the same data at the same time, so some conflict resolution mechanism is needed to handle this. +* **Master-Master replication:** In this type of replication, multiple servers are configured as "masters," and each one can accept read and write operations. This allows for high availability and allows any of the servers to take over if one of them fails. However, this type of replication can lead to conflicts if multiple servers update the same data at the same time, so some conflict resolution mechanism is needed to handle this. + +* **Master-Slave replication:** In this type of replication, one server is designated as the "master" and handles all write operations, while multiple "slave" servers handle read operations. If the master fails, one of the slaves can be promoted to take its place. This type of replication is simpler to set up and maintain compared to Master-Master replication. -- **Master-Slave replication:** In this type of replication, one server is designated as the "master" and handles all write operations, while multiple "slave" servers handle read operations. If the master fails, one of the slaves can be promoted to take its place. This type of replication is simpler to set up and maintain compared to Master-Master replication. +Visit the following resources to learn more: -Visit the following links for more resources: - -- [@opensource@Replication: Availability Pattern](https://github.com/donnemartin/system-design-primer#replication) +- [@opensource@Replication: Availability Pattern](https://github.com/donnemartin/system-design-primer#replication) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/replication@dc-aIbBwUdlwgwQKGrq49.md b/src/data/roadmaps/system-design/content/replication@dc-aIbBwUdlwgwQKGrq49.md index b432b045b..5a2df9dd2 100644 --- a/src/data/roadmaps/system-design/content/replication@dc-aIbBwUdlwgwQKGrq49.md +++ b/src/data/roadmaps/system-design/content/replication@dc-aIbBwUdlwgwQKGrq49.md @@ -2,10 +2,12 @@ Replication is the process of copying data from one database to another. Replication is used to increase availability and scalability of databases. There are two types of replication: master-slave and master-master. -## Master-slave Replication: +Master-slave Replication: +------------------------- The master serves reads and writes, replicating writes to one or more slaves, which serve only reads. Slaves can also replicate to additional slaves in a tree-like fashion. If the master goes offline, the system can continue to operate in read-only mode until a slave is promoted to a master or a new master is provisioned. -## Master-master Replication: +Master-master Replication: +-------------------------- -Both masters serve reads and writes and coordinate with each other on writes. If either master goes down, the system can continue to operate with both reads and writes. +Both masters serve reads and writes and coordinate with each other on writes. If either master goes down, the system can continue to operate with both reads and writes. \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/resiliency@wlAWMjxZF6yav3ZXOScxH.md b/src/data/roadmaps/system-design/content/resiliency@wlAWMjxZF6yav3ZXOScxH.md index 4880989cd..a554e924d 100644 --- a/src/data/roadmaps/system-design/content/resiliency@wlAWMjxZF6yav3ZXOScxH.md +++ b/src/data/roadmaps/system-design/content/resiliency@wlAWMjxZF6yav3ZXOScxH.md @@ -6,6 +6,6 @@ The nature of cloud hosting, where applications are often multi-tenant, use shar Detecting failures and recovering quickly and efficiently, is necessary to maintain resiliency. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Resiliency Patterns](https://learn.microsoft.com/en-us/azure/architecture/framework/resiliency/reliability-patterns#resiliency) +- [@article@Resiliency Patterns](https://learn.microsoft.com/en-us/azure/architecture/framework/resiliency/reliability-patterns#resiliency) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/rest@6-bgmfDTAQ9zABhpmVoHV.md b/src/data/roadmaps/system-design/content/rest@6-bgmfDTAQ9zABhpmVoHV.md index 0545e8cc5..bcdf086fa 100644 --- a/src/data/roadmaps/system-design/content/rest@6-bgmfDTAQ9zABhpmVoHV.md +++ b/src/data/roadmaps/system-design/content/rest@6-bgmfDTAQ9zABhpmVoHV.md @@ -4,15 +4,15 @@ REST is an architectural style enforcing a client/server model where the client There are four qualities of a RESTful interface: -- Identify resources (URI in HTTP) - use the same URI regardless of any operation. -- Change with representations (Verbs in HTTP) - use verbs, headers, and body. -- Self-descriptive error message (status response in HTTP) - Use status codes, don't reinvent the wheel. -- HATEOAS (HTML interface for HTTP) - your web service should be fully accessible in a browser. +* Identify resources (URI in HTTP) - use the same URI regardless of any operation. +* Change with representations (Verbs in HTTP) - use verbs, headers, and body. +* Self-descriptive error message (status response in HTTP) - Use status codes, don't reinvent the wheel. +* HATEOAS (HTML interface for HTTP) - your web service should be fully accessible in a browser. REST is focused on exposing data. It minimizes the coupling between client/server and is often used for public HTTP APIs. REST uses a more generic and uniform method of exposing resources through URIs, representation through headers, and actions through verbs such as GET, POST, PUT, DELETE, and PATCH. Being stateless, REST is great for horizontal scaling and partitioning. -To learn more, visit the following links: +Visit the following resources to learn more: - [@opensource@What Is REST?](https://github.com/donnemartin/system-design-primer#representational-state-transfer-rest) - [@article@What are the drawbacks of using RESTful APIs?](https://www.quora.com/What-are-the-drawbacks-of-using-RESTful-APIs) -- [@feed@Explore top posts about REST API](https://app.daily.dev/tags/rest-api?ref=roadmapsh) +- [@feed@Explore top posts about REST API](https://app.daily.dev/tags/rest-api?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/retry-storm@LNmAJmh2ndFtOQIpvX_ga.md b/src/data/roadmaps/system-design/content/retry-storm@LNmAJmh2ndFtOQIpvX_ga.md index cc1b907b2..6aff58ec5 100644 --- a/src/data/roadmaps/system-design/content/retry-storm@LNmAJmh2ndFtOQIpvX_ga.md +++ b/src/data/roadmaps/system-design/content/retry-storm@LNmAJmh2ndFtOQIpvX_ga.md @@ -2,7 +2,7 @@ Retry Storm 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: +Visit the following resources to learn more: - [@article@Retry Storm antipattern](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/retry-storm/) -- [@article@How To Avoid Retry Storms In Distributed Systems](https://faun.pub/how-to-avoid-retry-storms-in-distributed-systems-91bf34f43c7f) +- [@article@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/data/roadmaps/system-design/content/retry@xX_9VGUaOkBYFH3jPjnww.md b/src/data/roadmaps/system-design/content/retry@xX_9VGUaOkBYFH3jPjnww.md index ea343cf03..604909a15 100644 --- a/src/data/roadmaps/system-design/content/retry@xX_9VGUaOkBYFH3jPjnww.md +++ b/src/data/roadmaps/system-design/content/retry@xX_9VGUaOkBYFH3jPjnww.md @@ -2,6 +2,6 @@ Enable an application to handle transient failures when it tries to connect to a service or network resource, by transparently retrying a failed operation. This can improve the stability of the application. -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Retry pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/retry) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/returning-results@2gRIstNT-fTkv5GZ692gx.md b/src/data/roadmaps/system-design/content/returning-results@2gRIstNT-fTkv5GZ692gx.md index ac5a18507..a24ef9e34 100644 --- a/src/data/roadmaps/system-design/content/returning-results@2gRIstNT-fTkv5GZ692gx.md +++ b/src/data/roadmaps/system-design/content/returning-results@2gRIstNT-fTkv5GZ692gx.md @@ -2,6 +2,6 @@ Background jobs execute asynchronously in a separate process, or even in a separate location, from the UI or the process that invoked the background task. Ideally, background tasks are "fire and forget" operations, and their execution progress has no impact on the UI or the calling process. This means that the calling process does not wait for completion of the tasks. Therefore, it cannot automatically detect when the task ends. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Returning Results - Background Jobs](https://learn.microsoft.com/en-us/azure/architecture/best-practices/background-jobs#returning-results) +- [@article@Returning Results - Background Jobs](https://learn.microsoft.com/en-us/azure/architecture/best-practices/background-jobs#returning-results) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/rpc@ixqucoAkgnphWYAFnsMe-.md b/src/data/roadmaps/system-design/content/rpc@ixqucoAkgnphWYAFnsMe-.md index 613dda95f..ce60e6f39 100644 --- a/src/data/roadmaps/system-design/content/rpc@ixqucoAkgnphWYAFnsMe-.md +++ b/src/data/roadmaps/system-design/content/rpc@ixqucoAkgnphWYAFnsMe-.md @@ -4,35 +4,35 @@ In an RPC, a client causes a procedure to execute on a different address space, RPC is a request-response protocol: -- Client program - Calls the client stub procedure. The parameters are pushed onto the stack like a local procedure call. -- Client stub procedure - Marshals (packs) procedure id and arguments into a request message. -- Client communication module - OS sends the message from the client to the server. -- Server communication module - OS passes the incoming packets to the server stub procedure. -- Server stub procedure - Unmarshalls the results, calls the server procedure matching the procedure id and passes the given arguments. -- The server response repeats the steps above in reverse order. +* Client program - Calls the client stub procedure. The parameters are pushed onto the stack like a local procedure call. +* Client stub procedure - Marshals (packs) procedure id and arguments into a request message. +* Client communication module - OS sends the message from the client to the server. +* Server communication module - OS passes the incoming packets to the server stub procedure. +* Server stub procedure - Unmarshalls the results, calls the server procedure matching the procedure id and passes the given arguments. +* The server response repeats the steps above in reverse order. Sample RPC calls: -``` -GET /someoperation?data=anId - -POST /anotheroperation -{ - "data":"anId"; - "anotherdata": "another value" -} -``` + GET /someoperation?data=anId + + POST /anotheroperation + { + "data":"anId"; + "anotherdata": "another value" + } + RPC is focused on exposing behaviors. RPCs are often used for performance reasons with internal communications, as you can hand-craft native calls to better fit your use cases. -## Disadvantage of RPC +Disadvantage of RPC +------------------- -- RPC clients become tightly coupled to the service implementation. -- A new API must be defined for every new operation or use case. -- It can be difficult to debug RPC. -- You might not be able to leverage existing technologies out of the box. For example, it might require additional effort to ensure [RPC calls are properly cached](http://etherealbits.com/2012/12/debunking-the-myths-of-rpc-rest/) on caching servers such as [Squid](http://www.squid-cache.org/). +* RPC clients become tightly coupled to the service implementation. +* A new API must be defined for every new operation or use case. +* It can be difficult to debug RPC. +* You might not be able to leverage existing technologies out of the box. For example, it might require additional effort to ensure [RPC calls are properly cached](http://etherealbits.com/2012/12/debunking-the-myths-of-rpc-rest/) on caching servers such as [Squid](http://www.squid-cache.org/). -To learn more, visit the following links: +Visit the following resources to learn more: - [@opensource@What Is RPC?](https://github.com/donnemartin/system-design-primer#remote-procedure-call-rpc) -- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh) +- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/schedule-driven@zoViI4kzpKIxpU20T89K_.md b/src/data/roadmaps/system-design/content/schedule-driven@zoViI4kzpKIxpU20T89K_.md index b8d0be41b..00c24cdcf 100644 --- a/src/data/roadmaps/system-design/content/schedule-driven@zoViI4kzpKIxpU20T89K_.md +++ b/src/data/roadmaps/system-design/content/schedule-driven@zoViI4kzpKIxpU20T89K_.md @@ -2,12 +2,12 @@ Schedule-driven invocation uses a timer to start the background task. Examples of using schedule-driven triggers include: -- A timer that is running locally within the application or as part of the application's operating system invokes a background task on a regular basis. -- A timer that is running in a different application, such as Azure Logic Apps, sends a request to an API or web service on a regular basis. The API or web service invokes the background task. -- A separate process or application starts a timer that causes the background task to be invoked once after a specified time delay, or at a specific time. +* A timer that is running locally within the application or as part of the application's operating system invokes a background task on a regular basis. +* A timer that is running in a different application, such as Azure Logic Apps, sends a request to an API or web service on a regular basis. The API or web service invokes the background task. +* A separate process or application starts a timer that causes the background task to be invoked once after a specified time delay, or at a specific time. Typical examples of tasks that are suited to schedule-driven invocation include batch-processing routines (such as updating related-products lists for users based on their recent behavior), routine data processing tasks (such as updating indexes or generating accumulated results), data analysis for daily reports, data retention cleanup, and data consistency checks. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Schedule Driven - Background Jobs](https://learn.microsoft.com/en-us/azure/architecture/best-practices/background-jobs#schedule-driven-triggers) +- [@article@Schedule Driven - Background Jobs](https://learn.microsoft.com/en-us/azure/architecture/best-practices/background-jobs#schedule-driven-triggers) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/scheduler-agent-supervisor@RTEJHZ26znfBLrpQPtNvn.md b/src/data/roadmaps/system-design/content/scheduler-agent-supervisor@RTEJHZ26znfBLrpQPtNvn.md index bdd1ff76d..b10eac957 100644 --- a/src/data/roadmaps/system-design/content/scheduler-agent-supervisor@RTEJHZ26znfBLrpQPtNvn.md +++ b/src/data/roadmaps/system-design/content/scheduler-agent-supervisor@RTEJHZ26znfBLrpQPtNvn.md @@ -2,6 +2,6 @@ Coordinate a set of distributed actions as a single operation. If any of the actions fail, try to handle the failures transparently, or else undo the work that was performed, so the entire operation succeeds or fails as a whole. This can add resiliency to a distributed system, by enabling it to recover and retry actions that fail due to transient exceptions, long-lasting faults, and process failures. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Scheduler Agent Supervisor pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/scheduler-agent-supervisor) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/scheduling-agent-supervisor@uR1fU6pm7zTtdBcNgSRi4.md b/src/data/roadmaps/system-design/content/scheduling-agent-supervisor@uR1fU6pm7zTtdBcNgSRi4.md index cdd2787b5..b10eac957 100644 --- a/src/data/roadmaps/system-design/content/scheduling-agent-supervisor@uR1fU6pm7zTtdBcNgSRi4.md +++ b/src/data/roadmaps/system-design/content/scheduling-agent-supervisor@uR1fU6pm7zTtdBcNgSRi4.md @@ -2,6 +2,6 @@ Coordinate a set of distributed actions as a single operation. If any of the actions fail, try to handle the failures transparently, or else undo the work that was performed, so the entire operation succeeds or fails as a whole. This can add resiliency to a distributed system, by enabling it to recover and retry actions that fail due to transient exceptions, long-lasting faults, and process failures. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Scheduler Agent Supervisor pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/scheduler-agent-supervisor) +- [@article@Scheduler Agent Supervisor pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/scheduler-agent-supervisor) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/security-monitoring@I_NfmDcBph8-oyFVFTknL.md b/src/data/roadmaps/system-design/content/security-monitoring@I_NfmDcBph8-oyFVFTknL.md index 7fdfeafec..bd821053e 100644 --- a/src/data/roadmaps/system-design/content/security-monitoring@I_NfmDcBph8-oyFVFTknL.md +++ b/src/data/roadmaps/system-design/content/security-monitoring@I_NfmDcBph8-oyFVFTknL.md @@ -2,13 +2,13 @@ All commercial systems that include sensitive data must implement a security structure. The complexity of the security mechanism is usually a function of the sensitivity of the data. In a system that requires users to be authenticated, you should record: -- All sign-in attempts, whether they fail or succeed. -- All operations performed by—and the details of all resources accessed by—an authenticated user. -- When a user ends a session and signs out. +* All sign-in attempts, whether they fail or succeed. +* All operations performed by—and the details of all resources accessed by—an authenticated user. +* When a user ends a session and signs out. Monitoring might be able to help detect attacks on the system. For example, a large number of failed sign-in attempts might indicate a brute-force attack. An unexpected surge in requests might be the result of a distributed denial-of-service (DDoS) attack. You must be prepared to monitor all requests to all resources regardless of the source of these requests. A system that has a sign-in vulnerability might accidentally expose resources to the outside world without requiring a user to actually sign in. -Visit the following to learn more: +Visit the following resources to learn more: - [@article@Security Monitoring](https://learn.microsoft.com/en-us/azure/architecture/best-practices/monitoring#security-monitoring) -- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) +- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/security@ZvYpE6-N5dAtRDIwqcAu6.md b/src/data/roadmaps/system-design/content/security@ZvYpE6-N5dAtRDIwqcAu6.md index 1105f4995..c4bf15349 100644 --- a/src/data/roadmaps/system-design/content/security@ZvYpE6-N5dAtRDIwqcAu6.md +++ b/src/data/roadmaps/system-design/content/security@ZvYpE6-N5dAtRDIwqcAu6.md @@ -2,7 +2,7 @@ Security provides confidentiality, integrity, and availability assurances against malicious attacks on information systems (and safety assurances for attacks on operational technology systems). Losing these assurances can negatively impact your business operations and revenue, as well as your organization's reputation in the marketplace. Maintaining security requires following well-established practices (security hygiene) and being vigilant to detect and rapidly remediate vulnerabilities and active attacks. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Security patterns](https://learn.microsoft.com/en-us/azure/architecture/framework/security/security-patterns) -- [@feed@Explore top posts about Security](https://app.daily.dev/tags/security?ref=roadmapsh) +- [@feed@Explore top posts about Security](https://app.daily.dev/tags/security?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/sequential-convoy@VgvUWAC6JYFyPZKBRoEqf.md b/src/data/roadmaps/system-design/content/sequential-convoy@VgvUWAC6JYFyPZKBRoEqf.md index dd91b528f..7bad34bab 100644 --- a/src/data/roadmaps/system-design/content/sequential-convoy@VgvUWAC6JYFyPZKBRoEqf.md +++ b/src/data/roadmaps/system-design/content/sequential-convoy@VgvUWAC6JYFyPZKBRoEqf.md @@ -2,7 +2,7 @@ Sequential Convoy is a pattern that allows for the execution of a series of tasks, or convoy, in a specific order. This pattern can be used to ensure that a set of dependent tasks are executed in the correct order and to handle errors or failures during the execution of the tasks. It can be used in scenarios like workflow and transaction. It can be implemented using a variety of technologies such as state machines, workflows, and transactions. -Learn more from the following links: +Visit the following resources to learn more: - [@article@What is Sequential Convoy?](https://learn.microsoft.com/en-us/biztalk/core/sequential-convoys) -- [@article@Overview - Sequential Convoy pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/sequential-convoy) +- [@article@Overview - Sequential Convoy pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/sequential-convoy) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/service-discovery@Nt0HUWLOl4O77elF8Is1S.md b/src/data/roadmaps/system-design/content/service-discovery@Nt0HUWLOl4O77elF8Is1S.md index 62ce394f6..73c76e0d4 100644 --- a/src/data/roadmaps/system-design/content/service-discovery@Nt0HUWLOl4O77elF8Is1S.md +++ b/src/data/roadmaps/system-design/content/service-discovery@Nt0HUWLOl4O77elF8Is1S.md @@ -2,8 +2,8 @@ Systems such as [Consul](https://www.consul.io/docs/index.html), [Etcd](https://coreos.com/etcd/docs/latest), and [Zookeeper](http://www.slideshare.net/sauravhaloi/introduction-to-apache-zookeeper) can help services find each other by keeping track of registered names, addresses, and ports. [Health checks](https://www.consul.io/intro/getting-started/checks.html) help verify service integrity and are often done using an HTTP endpoint. Both Consul and Etcd have a built in key-value store that can be useful for storing config values and other shared data. -Visit the following links to learn more: +Visit the following resources to learn more: -- [@article@What is Service-oriented architecture?](https://en.wikipedia.org/wiki/Service-oriented_architecture) - [@opensource@Intro to Service Discovery](https://github.com/donnemartin/system-design-primer#Service-Discovery) -- [@feed@Explore top posts about Architecture](https://app.daily.dev/tags/architecture?ref=roadmapsh) +- [@article@What is Service-oriented architecture?](https://en.wikipedia.org/wiki/Service-oriented_architecture) +- [@feed@Explore top posts about Architecture](https://app.daily.dev/tags/architecture?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/sharding@FX6dcV_93zOfbZMdM_-li.md b/src/data/roadmaps/system-design/content/sharding@FX6dcV_93zOfbZMdM_-li.md index 503396b4a..5c388e8ae 100644 --- a/src/data/roadmaps/system-design/content/sharding@FX6dcV_93zOfbZMdM_-li.md +++ b/src/data/roadmaps/system-design/content/sharding@FX6dcV_93zOfbZMdM_-li.md @@ -4,8 +4,8 @@ Sharding distributes data across different databases such that each database can Similar to the advantages of federation, sharding results in less read and write traffic, less replication, and more cache hits. Index size is also reduced, which generally improves performance with faster queries. If one shard goes down, the other shards are still operational, although you'll want to add some form of replication to avoid data loss. Like federation, there is no single central master serializing writes, allowing you to write in parallel with increased throughput. -Learn more from the following links: +Visit the following resources to learn more: - [@article@The coming of the Shard](http://highscalability.com/blog/2009/8/6/an-unorthodox-approach-to-database-design-the-coming-of-the.html) -- [@article@Shard (database architecture)](https://en.wikipedia.org/wiki/Shard_\(database_architecture\)) -- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh) +- [@article@Shard (database architecture)](https://en.wikipedia.org/wiki/Shard_(database_architecture)) +- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/sharding@R6YehzA3X6DDo6oGBoBAx.md b/src/data/roadmaps/system-design/content/sharding@R6YehzA3X6DDo6oGBoBAx.md index d8f53acea..3e98af416 100644 --- a/src/data/roadmaps/system-design/content/sharding@R6YehzA3X6DDo6oGBoBAx.md +++ b/src/data/roadmaps/system-design/content/sharding@R6YehzA3X6DDo6oGBoBAx.md @@ -2,7 +2,7 @@ Sharding is a technique used to horizontally partition a large data set across multiple servers, in order to improve the performance, scalability, and availability of a system. This is done by breaking the data set into smaller chunks, called shards, and distributing the shards across multiple servers. Each shard is self-contained and can be managed and scaled independently of the other shards. Sharding can be used in scenarios like scalability, availability, and geo-distribution. Sharding can be implemented using several different algorithms such as range-based sharding, hash-based sharding, and directory-based sharding. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Sharding pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/sharding) -- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh) +- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/sidecar@AAgOGrra5Yz3_eG6tD2Fx.md b/src/data/roadmaps/system-design/content/sidecar@AAgOGrra5Yz3_eG6tD2Fx.md index daca64e6e..c393b5b11 100644 --- a/src/data/roadmaps/system-design/content/sidecar@AAgOGrra5Yz3_eG6tD2Fx.md +++ b/src/data/roadmaps/system-design/content/sidecar@AAgOGrra5Yz3_eG6tD2Fx.md @@ -4,7 +4,7 @@ Deploy components of an application into a separate process or container to prov This pattern is named Sidecar because it resembles a sidecar attached to a motorcycle. In the pattern, the sidecar is attached to a parent application and provides supporting features for the application. The sidecar also shares the same lifecycle as the parent application, being created and retired alongside the parent. The sidecar pattern is sometimes referred to as the sidekick pattern and is a decomposition pattern. -To learn more, visit the following links: +Visit the following resources to learn more: - [@article@Sidecar pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/sidecar) -- [@feed@Explore top posts about Infrastructure](https://app.daily.dev/tags/infrastructure?ref=roadmapsh) +- [@feed@Explore top posts about Infrastructure](https://app.daily.dev/tags/infrastructure?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/sql-tuning@fY8zgbB13wxZ1CFtMSdZZ.md b/src/data/roadmaps/system-design/content/sql-tuning@fY8zgbB13wxZ1CFtMSdZZ.md index 4771eb78c..ee10b8014 100644 --- a/src/data/roadmaps/system-design/content/sql-tuning@fY8zgbB13wxZ1CFtMSdZZ.md +++ b/src/data/roadmaps/system-design/content/sql-tuning@fY8zgbB13wxZ1CFtMSdZZ.md @@ -2,13 +2,13 @@ SQL tuning is the attempt to diagnose and repair SQL statements that fail to meet a performance standard. It is a broad topic and many books have been written as reference. It's important to benchmark and profile to simulate and uncover bottlenecks. -- Benchmark - Simulate high-load situations with tools such as ab. -- Profile - Enable tools such as the slow query log to help track performance issues. +* Benchmark - Simulate high-load situations with tools such as ab. +* Profile - Enable tools such as the slow query log to help track performance issues. Benchmarking and profiling might point you to the following optimizations. -To learn more, visit the following links: +Visit the following resources to learn more: - [@official@Introduction to SQL Tuning - Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/23/tgsql/introduction-to-sql-tuning.html#GUID-B653E5F3-F078-4BBC-9516-B892960046A2) - [@article@How we optimized PostgreSQL queries 100x](https://towardsdatascience.com/how-we-optimized-postgresql-queries-100x-ff52555eabe?gi=13caf5bcf32e) -- [@feed@Explore top posts about SQL](https://app.daily.dev/tags/sql?ref=roadmapsh) +- [@feed@Explore top posts about SQL](https://app.daily.dev/tags/sql?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/sql-vs-nosql@KLnpMR2FxlQkCHZP6-tZm.md b/src/data/roadmaps/system-design/content/sql-vs-nosql@KLnpMR2FxlQkCHZP6-tZm.md index ec363d020..32cec18b0 100644 --- a/src/data/roadmaps/system-design/content/sql-vs-nosql@KLnpMR2FxlQkCHZP6-tZm.md +++ b/src/data/roadmaps/system-design/content/sql-vs-nosql@KLnpMR2FxlQkCHZP6-tZm.md @@ -6,9 +6,9 @@ NoSQL databases, such as MongoDB and Cassandra, are best suited for unstructured The choice between SQL and NoSQL depends on the specific use case and requirements of the project. If you need to store and query structured data with complex relationships, an SQL database is likely a better choice. If you need to store and query large amounts of unstructured data with high scalability and performance, a NoSQL database may be a better choice. -Learn more from the following links: +Visit the following resources to learn more: - [@article@SQL vs NoSQL: The Differences](https://www.sitepoint.com/sql-vs-nosql-differences/) - [@article@SQL vs. NoSQL Databases: What’s the Difference?](https://www.ibm.com/blog/sql-vs-nosql/) - [@article@NoSQL vs. SQL Databases](https://www.mongodb.com/nosql-explained/nosql-vs-sql) -- [@feed@Explore top posts about NoSQL](https://app.daily.dev/tags/nosql?ref=roadmapsh) +- [@feed@Explore top posts about NoSQL](https://app.daily.dev/tags/nosql?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/static-content-hosting@-lKq-LT7EPK7r3xbXLgwS.md b/src/data/roadmaps/system-design/content/static-content-hosting@-lKq-LT7EPK7r3xbXLgwS.md index f46161ec0..02190f46c 100644 --- a/src/data/roadmaps/system-design/content/static-content-hosting@-lKq-LT7EPK7r3xbXLgwS.md +++ b/src/data/roadmaps/system-design/content/static-content-hosting@-lKq-LT7EPK7r3xbXLgwS.md @@ -2,6 +2,6 @@ Deploy static content to a cloud-based storage service that can deliver them directly to the client. This can reduce the need for potentially expensive compute instances. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Static Content Hosting pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/static-content-hosting) +- [@article@Static Content Hosting pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/static-content-hosting) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/static-content-hosting@izPT8NfJy1JC6h3i7GJYl.md b/src/data/roadmaps/system-design/content/static-content-hosting@izPT8NfJy1JC6h3i7GJYl.md index f46161ec0..02190f46c 100644 --- a/src/data/roadmaps/system-design/content/static-content-hosting@izPT8NfJy1JC6h3i7GJYl.md +++ b/src/data/roadmaps/system-design/content/static-content-hosting@izPT8NfJy1JC6h3i7GJYl.md @@ -2,6 +2,6 @@ Deploy static content to a cloud-based storage service that can deliver them directly to the client. This can reduce the need for potentially expensive compute instances. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Static Content Hosting pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/static-content-hosting) +- [@article@Static Content Hosting pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/static-content-hosting) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/strangler-fig@VIbXf7Jh9PbQ9L-g6pHUG.md b/src/data/roadmaps/system-design/content/strangler-fig@VIbXf7Jh9PbQ9L-g6pHUG.md index 833478ee8..751750ecb 100644 --- a/src/data/roadmaps/system-design/content/strangler-fig@VIbXf7Jh9PbQ9L-g6pHUG.md +++ b/src/data/roadmaps/system-design/content/strangler-fig@VIbXf7Jh9PbQ9L-g6pHUG.md @@ -2,6 +2,6 @@ Incrementally migrate a legacy system by gradually replacing specific pieces of functionality with new applications and services. As features from the legacy system are replaced, the new system eventually replaces all of the old system's features, strangling the old system and allowing you to decommission it. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@What is Strangler fig?](https://learn.microsoft.com/en-us/azure/architecture/patterns/strangler-fig) +- [@article@What is Strangler fig?](https://learn.microsoft.com/en-us/azure/architecture/patterns/strangler-fig) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/strong-consistency@JjB7eB8gdRCAYf5M0RcT7.md b/src/data/roadmaps/system-design/content/strong-consistency@JjB7eB8gdRCAYf5M0RcT7.md index f9ce8dfb1..b97708c39 100644 --- a/src/data/roadmaps/system-design/content/strong-consistency@JjB7eB8gdRCAYf5M0RcT7.md +++ b/src/data/roadmaps/system-design/content/strong-consistency@JjB7eB8gdRCAYf5M0RcT7.md @@ -2,6 +2,6 @@ After an update is made to the data, it will be immediately visible to any subsequent read operations. The data is replicated in a synchronous manner, ensuring that all copies of the data are updated at the same time. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Consistency Patterns in Distributed Systems](https://cs.fyi/guide/consistency-patterns-week-strong-eventual/) +- [@article@Consistency Patterns in Distributed Systems](https://cs.fyi/guide/consistency-patterns-week-strong-eventual/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/synchronous-io@Ihnmxo_bVgZABDwg1QGGk.md b/src/data/roadmaps/system-design/content/synchronous-io@Ihnmxo_bVgZABDwg1QGGk.md index 366d1ad0a..8b14b5de3 100644 --- a/src/data/roadmaps/system-design/content/synchronous-io@Ihnmxo_bVgZABDwg1QGGk.md +++ b/src/data/roadmaps/system-design/content/synchronous-io@Ihnmxo_bVgZABDwg1QGGk.md @@ -6,18 +6,18 @@ A synchronous I/O operation blocks the calling thread while the I/O completes. T Common examples of I/O include: -- Retrieving or persisting data to a database or any type of persistent storage. -- Sending a request to a web service. -- Posting a message or retrieving a message from a queue. -- Writing to or reading from a local file. +* Retrieving or persisting data to a database or any type of persistent storage. +* Sending a request to a web service. +* Posting a message or retrieving a message from a queue. +* Writing to or reading from a local file. This antipattern typically occurs because: -- It appears to be the most intuitive way to perform an operation. -- The application requires a response from a request. -- The application uses a library that only provides synchronous methods for I/O. -- An external library performs synchronous I/O operations internally. A single synchronous I/O call can block an entire call chain. +* It appears to be the most intuitive way to perform an operation. +* The application requires a response from a request. +* The application uses a library that only provides synchronous methods for I/O. +* An external library performs synchronous I/O operations internally. A single synchronous I/O call can block an entire call chain. -Visit the following links to learn more: +Visit the following resources to learn more: -- [@article@What is Synchronous I/O antipattern?](https://learn.microsoft.com/en-us/azure/architecture/antipatterns/synchronous-io/) +- [@article@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/data/roadmaps/system-design/content/task-queues@a9wGW_H1HpvvdYCXoS-Rf.md b/src/data/roadmaps/system-design/content/task-queues@a9wGW_H1HpvvdYCXoS-Rf.md index 06cfc58c3..1de70f72f 100644 --- a/src/data/roadmaps/system-design/content/task-queues@a9wGW_H1HpvvdYCXoS-Rf.md +++ b/src/data/roadmaps/system-design/content/task-queues@a9wGW_H1HpvvdYCXoS-Rf.md @@ -4,6 +4,6 @@ Tasks queues receive tasks and their related data, runs them, then delivers thei [Celery](https://docs.celeryproject.org/en/stable/) has support for scheduling and primarily has python support. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Celery - Distributed Task Queue](https://docs.celeryq.dev/en/stable/) +- [@article@Celery - Distributed Task Queue](https://docs.celeryq.dev/en/stable/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/tcp@2nF5uC6fYKbf0RFgGNHiP.md b/src/data/roadmaps/system-design/content/tcp@2nF5uC6fYKbf0RFgGNHiP.md index c0fc124c1..71c6106dd 100644 --- a/src/data/roadmaps/system-design/content/tcp@2nF5uC6fYKbf0RFgGNHiP.md +++ b/src/data/roadmaps/system-design/content/tcp@2nF5uC6fYKbf0RFgGNHiP.md @@ -2,10 +2,10 @@ TCP is a connection-oriented protocol over an [IP network](https://en.wikipedia.org/wiki/Internet_Protocol). Connection is established and terminated using a [handshake](https://en.wikipedia.org/wiki/Handshaking). All packets sent are guaranteed to reach the destination in the original order and without corruption through: -- Sequence numbers and [checksum fields](https://en.wikipedia.org/wiki/Transmission_Control_Protocol#Checksum_computation) for each packet -- [@article@Acknowledgement](https://en.wikipedia.org/wiki/Acknowledgement_(data_networks)) packets and automatic retransmission +* Sequence numbers and [checksum fields](https://en.wikipedia.org/wiki/Transmission_Control_Protocol#Checksum_computation) for each packet +* [@article@Acknowledgement](https://en.wikipedia.org/wiki/Acknowledgement_\(data_networks\)) packets and automatic retransmission -If the sender does not receive a correct response, it will resend the packets. If there are multiple timeouts, the connection is dropped. TCP also implements [flow control]() and congestion control. These guarantees cause delays and generally result in less efficient transmission than UDP. +If the sender does not receive a correct response, it will resend the packets. If there are multiple timeouts, the connection is dropped. TCP also implements [flow control](https://en.wikipedia.org/wiki/Flow_control_\(data\)) and congestion control. These guarantees cause delays and generally result in less efficient transmission than UDP. To ensure high throughput, web servers can keep a large number of TCP connections open, resulting in high memory usage. It can be expensive to have a large number of open connections between web server threads and say, a [memcached server](https://memcached.org/). [Connection pooling](https://en.wikipedia.org/wiki/Connection_pool) can help in addition to switching to UDP where applicable. @@ -13,10 +13,10 @@ TCP is useful for applications that require high reliability but are less time c Use TCP over UDP when: -- You need all of the data to arrive intact -- You want to automatically make a best estimate use of the network throughput +* You need all of the data to arrive intact +* You want to automatically make a best estimate use of the network throughput -To learn more, visit the following links: +Visit the following resources to learn more: - [@opensource@What Is TCP?](https://github.com/donnemartin/system-design-primer#transmission-control-protocol-tcp) - [@article@What is the difference between HTTP protocol and TCP protocol?](https://www.quora.com/What-is-the-difference-between-HTTP-protocol-and-TCP-protocol) @@ -25,4 +25,4 @@ To learn more, visit the following links: - [@article@Difference between TCP and UDP](http://stackoverflow.com/questions/5970383/difference-between-tcp-and-udp) - [@article@Transmission control protocol](https://en.wikipedia.org/wiki/Transmission_Control_Protocol) - [@article@User datagram protocol](https://en.wikipedia.org/wiki/User_Datagram_Protocol) -- [@article@Scaling memcache at Facebook](http://www.cs.bu.edu/~jappavoo/jappavoo.github.com/451/papers/memcache-fb.pdf) +- [@article@Scaling memcache at Facebook](http://www.cs.bu.edu/~jappavoo/jappavoo.github.com/451/papers/memcache-fb.pdf) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/throttling@6YVkguDOtwveyeP4Z1NL3.md b/src/data/roadmaps/system-design/content/throttling@6YVkguDOtwveyeP4Z1NL3.md index 021b5d46b..6231d0876 100644 --- a/src/data/roadmaps/system-design/content/throttling@6YVkguDOtwveyeP4Z1NL3.md +++ b/src/data/roadmaps/system-design/content/throttling@6YVkguDOtwveyeP4Z1NL3.md @@ -2,6 +2,6 @@ Control the consumption of resources used by an instance of an application, an individual tenant, or an entire service. This can allow the system to continue to function and meet service level agreements, even when an increase in demand places an extreme load on resources. -To learn more visit the following links: +Visit the following resources to learn more: - [@article@Throttling pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/throttling) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/udp@LC5aTmUKNiw9RuSUt3fSE.md b/src/data/roadmaps/system-design/content/udp@LC5aTmUKNiw9RuSUt3fSE.md index f9b944f8f..417dbd7f3 100644 --- a/src/data/roadmaps/system-design/content/udp@LC5aTmUKNiw9RuSUt3fSE.md +++ b/src/data/roadmaps/system-design/content/udp@LC5aTmUKNiw9RuSUt3fSE.md @@ -8,15 +8,15 @@ UDP is less reliable but works well in real time use cases such as VoIP, video c Use UDP over TCP when: -- You need the lowest latency -- Late data is worse than loss of data -- You want to implement your own error correction +* You need the lowest latency +* Late data is worse than loss of data +* You want to implement your own error correction -To learn more, visit the following link: +Visit the following resources to learn more: - [@article@Networking for game programming](http://gafferongames.com/networking-for-game-programmers/udp-vs-tcp/) - [@article@Key differences between TCP and UDP protocols](http://www.cyberciti.biz/faq/key-differences-between-tcp-and-udp-protocols/) - [@article@Difference between TCP and UDP](http://stackoverflow.com/questions/5970383/difference-between-tcp-and-udp) - [@article@Transmission control protocol](https://en.wikipedia.org/wiki/Transmission_Control_Protocol) - [@article@User datagram protocol](https://en.wikipedia.org/wiki/User_Datagram_Protocol) -- [@article@Scaling memcache at Facebook](http://www.cs.bu.edu/~jappavoo/jappavoo.github.com/451/papers/memcache-fb.pdf) +- [@article@Scaling memcache at Facebook](http://www.cs.bu.edu/~jappavoo/jappavoo.github.com/451/papers/memcache-fb.pdf) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/usage-monitoring@eSZq74lROh5lllLyTBK5a.md b/src/data/roadmaps/system-design/content/usage-monitoring@eSZq74lROh5lllLyTBK5a.md index 6b96381b1..023009cd4 100644 --- a/src/data/roadmaps/system-design/content/usage-monitoring@eSZq74lROh5lllLyTBK5a.md +++ b/src/data/roadmaps/system-design/content/usage-monitoring@eSZq74lROh5lllLyTBK5a.md @@ -2,13 +2,13 @@ Usage monitoring tracks how the features and components of an application are used. An operator can use the gathered data to: -- Determine which features are heavily used and determine any potential hotspots in the system. High-traffic elements might benefit from functional partitioning or even replication to spread the load more evenly. An operator can also use this information to ascertain which features are infrequently used and are possible candidates for retirement or replacement in a future version of the system. -- Obtain information about the operational events of the system under normal use. For example, in an e-commerce site, you can record the statistical information about the number of transactions and the volume of customers that are responsible for them. This information can be used for capacity planning as the number of customers grows. -- Detect (possibly indirectly) user satisfaction with the performance or functionality of the system. For example, if a large number of customers in an e-commerce system regularly abandon their shopping carts, this might be due to a problem with the checkout functionality. -- Generate billing information. A commercial application or multitenant service might charge customers for the resources that they use. -- Enforce quotas. If a user in a multitenant system exceeds their paid quota of processing time or resource usage during a specified period, their access can be limited or processing can be throttled. +* Determine which features are heavily used and determine any potential hotspots in the system. High-traffic elements might benefit from functional partitioning or even replication to spread the load more evenly. An operator can also use this information to ascertain which features are infrequently used and are possible candidates for retirement or replacement in a future version of the system. +* Obtain information about the operational events of the system under normal use. For example, in an e-commerce site, you can record the statistical information about the number of transactions and the volume of customers that are responsible for them. This information can be used for capacity planning as the number of customers grows. +* Detect (possibly indirectly) user satisfaction with the performance or functionality of the system. For example, if a large number of customers in an e-commerce system regularly abandon their shopping carts, this might be due to a problem with the checkout functionality. +* Generate billing information. A commercial application or multitenant service might charge customers for the resources that they use. +* Enforce quotas. If a user in a multitenant system exceeds their paid quota of processing time or resource usage during a specified period, their access can be limited or processing can be throttled. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Usage Monitoring](https://learn.microsoft.com/en-us/azure/architecture/best-practices/monitoring#usage-monitoring) -- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) +- [@feed@Explore top posts about Monitoring](https://app.daily.dev/tags/monitoring?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/valet-key@VltZgIrApHOwZ8YHvdmHB.md b/src/data/roadmaps/system-design/content/valet-key@VltZgIrApHOwZ8YHvdmHB.md index ae33bb55d..c4dbd6519 100644 --- a/src/data/roadmaps/system-design/content/valet-key@VltZgIrApHOwZ8YHvdmHB.md +++ b/src/data/roadmaps/system-design/content/valet-key@VltZgIrApHOwZ8YHvdmHB.md @@ -2,6 +2,6 @@ Use a token that provides clients with restricted direct access to a specific resource, in order to offload data transfer from the application. This is particularly useful in applications that use cloud-hosted storage systems or queues, and can minimize cost and maximize scalability and performance. -Learn more from the following links: +Visit the following resources to learn more: - [@article@Valet Key pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/valet-key) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/valet-key@stZOcr8EUBOK_ZB48uToj.md b/src/data/roadmaps/system-design/content/valet-key@stZOcr8EUBOK_ZB48uToj.md index c1fbe1201..c4dbd6519 100644 --- a/src/data/roadmaps/system-design/content/valet-key@stZOcr8EUBOK_ZB48uToj.md +++ b/src/data/roadmaps/system-design/content/valet-key@stZOcr8EUBOK_ZB48uToj.md @@ -2,6 +2,6 @@ Use a token that provides clients with restricted direct access to a specific resource, in order to offload data transfer from the application. This is particularly useful in applications that use cloud-hosted storage systems or queues, and can minimize cost and maximize scalability and performance. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Valet Key pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/valet-key) +- [@article@Valet Key pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/valet-key) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/visualization--alerts@IwMOTpsYHApdvHZOhXtIw.md b/src/data/roadmaps/system-design/content/visualization--alerts@IwMOTpsYHApdvHZOhXtIw.md index 8018c669d..fec14b28e 100644 --- a/src/data/roadmaps/system-design/content/visualization--alerts@IwMOTpsYHApdvHZOhXtIw.md +++ b/src/data/roadmaps/system-design/content/visualization--alerts@IwMOTpsYHApdvHZOhXtIw.md @@ -2,6 +2,6 @@ An important aspect of any monitoring system is the ability to present the data in such a way that an operator can quickly spot any trends or problems. Also important is the ability to quickly inform an operator if a significant event has occurred that might require attention. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Visualize Data and Raise Alerts](https://learn.microsoft.com/en-us/azure/architecture/best-practices/monitoring#visualizing-data-and-raising-alerts) +- [@article@Visualize Data and Raise Alerts](https://learn.microsoft.com/en-us/azure/architecture/best-practices/monitoring#visualizing-data-and-raising-alerts) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/weak-consistency@EKD5AikZtwjtsEYRPJhQ2.md b/src/data/roadmaps/system-design/content/weak-consistency@EKD5AikZtwjtsEYRPJhQ2.md index 1870cc2b1..dee2e4089 100644 --- a/src/data/roadmaps/system-design/content/weak-consistency@EKD5AikZtwjtsEYRPJhQ2.md +++ b/src/data/roadmaps/system-design/content/weak-consistency@EKD5AikZtwjtsEYRPJhQ2.md @@ -2,6 +2,6 @@ After an update is made to the data, it is not guaranteed that any subsequent read operation will immediately reflect the changes made. The read may or may not see the recent write. -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Consistency Patterns in Distributed Systems](https://cs.fyi/guide/consistency-patterns-week-strong-eventual/) +- [@article@Consistency Patterns in Distributed Systems](https://cs.fyi/guide/consistency-patterns-week-strong-eventual/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/web-server-caching@o532nPnL-d2vXJn9k6vMl.md b/src/data/roadmaps/system-design/content/web-server-caching@o532nPnL-d2vXJn9k6vMl.md index 314e23e9e..3de091531 100644 --- a/src/data/roadmaps/system-design/content/web-server-caching@o532nPnL-d2vXJn9k6vMl.md +++ b/src/data/roadmaps/system-design/content/web-server-caching@o532nPnL-d2vXJn9k6vMl.md @@ -1,3 +1,3 @@ # Web Server Caching -[Reverse proxies](https://github.com/donnemartin/system-design-primer#reverse-proxy-web-server) and caches such as [Varnish](https://www.varnish-cache.org/) can serve static and dynamic content directly. Web servers can also cache requests, returning responses without having to contact application servers. +[Reverse proxies](https://github.com/donnemartin/system-design-primer#reverse-proxy-web-server) and caches such as [Varnish](https://www.varnish-cache.org/) can serve static and dynamic content directly. Web servers can also cache requests, returning responses without having to contact application servers. \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/what-is-system-design@idLHBxhvcIqZTqmh_E8Az.md b/src/data/roadmaps/system-design/content/what-is-system-design@idLHBxhvcIqZTqmh_E8Az.md index 0e2769674..6982467ee 100644 --- a/src/data/roadmaps/system-design/content/what-is-system-design@idLHBxhvcIqZTqmh_E8Az.md +++ b/src/data/roadmaps/system-design/content/what-is-system-design@idLHBxhvcIqZTqmh_E8Az.md @@ -6,4 +6,4 @@ It involves taking a problem statement, breaking it down into smaller components In software engineering, system design is a phase in the software development process that focuses on the high-level design of a software system, including the architecture and components. -It is also one of the important aspects of the interview process for software engineers. Most of the companies have a dedicated system design interview round, where they ask the candidates to design a system for a given problem statement. The candidates are expected to come up with a detailed design of the system, including the architecture, components, and their interactions. They are also expected to discuss the trade-offs involved in their design and the alternatives that they considered. +It is also one of the important aspects of the interview process for software engineers. Most of the companies have a dedicated system design interview round, where they ask the candidates to design a system for a given problem statement. The candidates are expected to come up with a detailed design of the system, including the architecture, components, and their interactions. They are also expected to discuss the trade-offs involved in their design and the alternatives that they considered. \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/wide-column-store@WHq1AdISkcgthaugE9uY7.md b/src/data/roadmaps/system-design/content/wide-column-store@WHq1AdISkcgthaugE9uY7.md index 8f13973fb..b0ee273f2 100644 --- a/src/data/roadmaps/system-design/content/wide-column-store@WHq1AdISkcgthaugE9uY7.md +++ b/src/data/roadmaps/system-design/content/wide-column-store@WHq1AdISkcgthaugE9uY7.md @@ -4,6 +4,6 @@ A wide column store's basic unit of data is a column (name/value pair). A column Google introduced Bigtable as the first wide column store, which influenced the open-source HBase often-used in the Hadoop ecosystem, and Cassandra from Facebook. Stores such as BigTable, HBase, and Cassandra maintain keys in lexicographic order, allowing efficient retrieval of selective key ranges. -Learn more from the following links: +Visit the following resources to learn more: -- [@article@Bigtable architecture](https://www.read.seas.harvard.edu/~kohler/class/cs239-w08/chang06bigtable.pdf) +- [@article@Bigtable architecture](https://www.read.seas.harvard.edu/~kohler/class/cs239-w08/chang06bigtable.pdf) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/write-behind@vNndJ-MWetcbaF2d-3-JP.md b/src/data/roadmaps/system-design/content/write-behind@vNndJ-MWetcbaF2d-3-JP.md index 301e1c667..294cd4a55 100644 --- a/src/data/roadmaps/system-design/content/write-behind@vNndJ-MWetcbaF2d-3-JP.md +++ b/src/data/roadmaps/system-design/content/write-behind@vNndJ-MWetcbaF2d-3-JP.md @@ -2,16 +2,17 @@ In write-behind, the application does the following: -- Add/update entry in cache -- Asynchronously write entry to the data store, improving write performance +* Add/update entry in cache +* Asynchronously write entry to the data store, improving write performance -## Disadvantages of write-behind: +Disadvantages of write-behind: +------------------------------ -- There could be data loss if the cache goes down prior to its contents hitting the data store. -- It is more complex to implement write-behind than it is to implement cache-aside or write-through. +* There could be data loss if the cache goes down prior to its contents hitting the data store. +* It is more complex to implement write-behind than it is to implement cache-aside or write-through. ![Scalability, availability, stability, patterns](https://i.imgur.com/XDsb7RS.png) -To learn more, visit the following links: +Visit the following resources to learn more: -- [@article@Scalability, availability, stability, patterns](http://www.slideshare.net/jboner/scalability-availability-stability-patterns/) +- [@article@Scalability, availability, stability, patterns](http://www.slideshare.net/jboner/scalability-availability-stability-patterns/) \ No newline at end of file diff --git a/src/data/roadmaps/system-design/content/write-through@RNITLR1FUQWkRbSBXTD_z.md b/src/data/roadmaps/system-design/content/write-through@RNITLR1FUQWkRbSBXTD_z.md index 434349b81..62d2089f2 100644 --- a/src/data/roadmaps/system-design/content/write-through@RNITLR1FUQWkRbSBXTD_z.md +++ b/src/data/roadmaps/system-design/content/write-through@RNITLR1FUQWkRbSBXTD_z.md @@ -2,33 +2,32 @@ The application uses the cache as the main data store, reading and writing data to it, while the cache is responsible for reading and writing to the database: -- Application adds/updates entry in cache -- Cache synchronously writes entry to data store -- Return +* Application adds/updates entry in cache +* Cache synchronously writes entry to data store +* Return Application code: -```python -set_user(12345, {"foo": "bar"}) -``` + set_user(12345, {"foo": "bar"}) + Cache code: -```python -def set_user(user_id, values): - user = db.query("UPDATE Users WHERE id = {0}", user_id, values) - cache.set(user_id, user) -``` + def set_user(user_id, values): + user = db.query("UPDATE Users WHERE id = {0}", user_id, values) + cache.set(user_id, user) + Write-through is a slow overall operation due to the write operation, but subsequent reads of just written data are fast. Users are generally more tolerant of latency when updating data than reading data. Data in the cache is not stale. -## Disadvantages +Disadvantages +------------- -- When a new node is created due to failure or scaling, the new node will not cache entries until the entry is updated in the database. Cache-aside in conjunction with write through can mitigate this issue. -- Most data written might never be read, which can be minimized with a TTL. +* When a new node is created due to failure or scaling, the new node will not cache entries until the entry is updated in the database. Cache-aside in conjunction with write through can mitigate this issue. +* Most data written might never be read, which can be minimized with a TTL. ![Write through](https://i.imgur.com/Ujf0awN.png) -Have a look at the following resources to learn more: +Visit the following resources to learn more: -- [@article@Scalability, availability, stability, patterns](http://www.slideshare.net/jboner/scalability-availability-stability-patterns/) +- [@article@Scalability, availability, stability, patterns](http://www.slideshare.net/jboner/scalability-availability-stability-patterns/) \ No newline at end of file