Design Patterns for Building Scalable Applications

In this week, we will understand what is scalability by taking references from the real world businesses and we will also look into the importance of consistency and availability in achieving scalability for such businesses

• Scalability in a distributed world
• Scalability
• Scalability in real world
• Consistency
• Availability

In this week, we will learn about, distributed systems and its working, we will look into CAP theorem and how these 3 attributes, “consistency, availability and partition tolerance” helps in building a scalable system.

• Distributed Systems
• Reasons for building scalable systems
• Consistency in distributed systems
• Laws of scalability
• Laws of scalability review
• CAP theorem
• Understanding CAP theorem with an example
• Understanding the terms of the CAP theorem
• Understanding CP with MongoDB
• CAP theorem review

This week, we will learn about  load balancers and how they  help to diversify “input requests traffic” and balance these requests among the backend servers. We will also learn about CDN, reverse proxies, message queues and how they help in decoupling an application for better performance.

• Load balancers 
• Messaging queues
• Caches
• Reverse proxies
• CDN
• NoSQL databases
• Embedded databases
• Cloud
• Language features
• Frameworks
• Design rules derived from design principles

Design patterns help in solving distributed world challenges. This week, we will look into the software design patterns and their major categories.

• What are design patterns?
• Uses of design patterns
• State of art design patterns
• The Google Pregel Graph processing project and the Hama project
• Design patterns in detail
• Load balancer
• Scatter and gather
• Result cache
• Shared space
• Pipe and filter
• Map reduce
• Bulk synchronous parallel
• Execution orchestrator
• Project

This week, we will focus on scaling out in a shared-nothing architecture and how it is a highly decoupled architecture. We will also look into sharding, master-slave architecture and how it can be used in case of a parallel distributed system and connection pool uses.

• Shared-nothing architecture
• Horizontal vs vertical scaling 
• Example for shared-nothing architecture
• Database sharding
• Master slave database
• Connection pooling
• Near real-time synchronization of data

In this week, we will be introduced to microservices patterns and will get an understanding about

• Design and architectural patterns
• Publisher/Subscriber pattern
• Advantages of Pub/Sub pattern
• Bottlenecks of Pub/Sub pattern
• Scheduler-Agent-Supervisor
• Priority Queue pattern
• Cache-Aside pattern
• Queue-Based Load Levelling pattern
• Throttling pattern

This week, we will deep dive into microservices architecture methods and how it is a better alternative monolithic architecture. Further we will look into, data management patterns like database per service, CQRS and event sourcing and its uses, benefits and examples.

• Microservices architecture
• Best practices for Microservices
• Data management design patterns for scalable microservices
• Database per service pattern
• Event Sourcing pattern
• Command Query Responsibility
• Segregation (CQRS) pattern

In this week, as the title suggests we will look into various patterns in microservices architecture and learn the uniqueness, uses and benefits of each pattern. By the end of this week, you will have a clear idea on which patterns to use according to the business requirement and set up.

• Saga pattern
• Backend for frontend
• API gateway
• Strangler pattern
• Circuit breaker pattern
• Externalized configuration
• Consumer driven contract testing

In this week, we will revisit the patterns that we leant previously and learn a few more patterns like decomposition and integration patterns and its types. We will be able to get a new perspective on the microservices patterns used with respect to the business capabilities.

• Revisiting design patterns for microservices
• Decomposition patterns
• Integration Patterns

In this week, we will look into more patterns like observability and cross-cutting concern patterns and its types and uses to scale a system. We will design an alternative or similar relational database using the patterns and understand the different types of distributed tracing patterns.

• Observability patterns
• Log aggregation pattern
• Distributed tracing pattern
• Health check pattern
• Cross-cutting concern patterns
• External configuration pattern
• Service Discovery pattern
• Blue green deployment pattern

We will look into the usages of design patterns in leading organizations like ThoughtWorks and understand their working principle. We will also learn about the usage of design patterns in music corp events and we will learn how to build service integration.

• State of the art-design patterns usage in leading organizations
• Scaling microservices event stream at Thoughtworks
• Thoughtworks: Service orchestration
• Thoughtworks: Service choreography with event stream
• Understanding the music corp event
• Customer creation: Publishing the event
• Email service: Subscribing the event
• Scaling the microservices with all the challenges and bottlenecks in mind
• Building services integration
• Uber’s distributed tracing infrastructure
• Uber: quest for the perfect tracing tool
• Using the existing methodologies to advantage
• TChannel generated traces
• Scalability best practices from ebay

In the last section of the course, we will be looking into a case study, we will be able to think in real time and hence provide real time solutions using the patterns and systems that we learnt in this course.

• Case study
• Popular patterns to scale a system
• Revision of some commonly used patterns