We may earn an affiliate commission when you visit our partners.
Lukasz Antoniak

Significant percentage of large scale enterprises that I have been working with, admitted experiencing performance issues with their business critical applications. Most of production systems have been built on top of legacy, monolith technologies. Recent popularity of micro-services will not fulfill its promise of decoupled, scalable and fault-tolerant systems, unless "done right". While entering the world of micro-services, engineers start building distributed applications, where robust remote procedure calls and cluster coordination are a must.

Read more

Significant percentage of large scale enterprises that I have been working with, admitted experiencing performance issues with their business critical applications. Most of production systems have been built on top of legacy, monolith technologies. Recent popularity of micro-services will not fulfill its promise of decoupled, scalable and fault-tolerant systems, unless "done right". While entering the world of micro-services, engineers start building distributed applications, where robust remote procedure calls and cluster coordination are a must.

In this course you will learn about common challenges that appear while designing and implementing large scale distributed systems, and how Big-Tech companies solve those problems.

Technologies, algorithms and design patterns covered in this course:

  • Service Registry and Discovery, Service Mesh

  • Apache Cassandra

  • ETCD (coordinator managing Kubernetes clusters)

  • Apache Kafka

  • Idempotent service design, retry logic

  • Sharding and Consistent Hashing

  • Client-side Load Balancing, Distributed Tracing, Canary Deployment, Sidecar Pattern, Circuit Breaker

Course will teach you the principles of various distributed systems design, for example master-less vs. with leaders, poll-based vs. push-based, immediate vs. eventual consistency. After completing the course, learning new distributed database technology would be easier, because you will know the common re-used techniques, including their pros and cons.

My intention is to keep course content very practical, with lots of code examples and applied best practices. For example, I will cover Service Registry and Discovery to the detail, that you will know how to implement your own framework on top of ETCD. Throughout the course, we are going to build distributed URL shorten service.

The course may be a good recap for people preparing for systems design interview.

Enroll now

What's inside

Learning objectives

  • Design and implement globally-distributed, scalable and fault-tolerant applications
  • Understanding of common algorithms and techniques used in majority of nosql databases and streaming platforms
  • In-depth knowledge of apache cassandra, apache kafka and etcd
  • Build distributed url-shorten service

Syllabus

Traditional RDBMS systems vs. NoSQL
Data sharding and consistent hashing
Concepts of Distributed Systems
Evolution of computer system’s architecture
Read more
Challenges of distributed computing
Use-case of course application
Practice 1
Remote Procedure Call
The need of communication
Message transport and format
Synchronous and asynchronous communication patterns
Traditional load balancers
Service Registry and Discovery
Service meshes
Idempotent service design
Practice 2
Distributed Databases
CAP theorem
Short introduction to Apache Cassandra
Practice 3
Cluster Coordination
The need of cluster-wide coordination
RAFT consensus algorithm
Short introduction to Etcd
Implementation of distributed mutex
Leader election design pattern
Deployment requirements for strongly consistent distributed systems
ACID properties in distributed system
Practice 4
Distributed Messaging Systems
Asynchronous communication pattern and message-oriented middleware
Short introduction to Apache Kafka
Apache Kafka as a distributed system
Event-driven architecture
Practice 5

Good to know

Know what's good
, what to watch for
, and possible dealbreakers
Explores service registry and discovery in detail, which allows learners to implement their own frameworks on top of ETCD, enhancing their practical skills
Covers technologies like Apache Cassandra, Kafka, and ETCD, which are widely used in modern distributed systems and are highly relevant to industry practices
Teaches principles of various distributed systems designs, such as master-less vs with leaders, poll-based vs push-based, and immediate vs eventual consistency
Includes hands-on practices with technologies like Cassandra, Kafka, and ETCD, which allows learners to apply the concepts and build practical skills
Examines challenges that appear while designing and implementing large-scale distributed systems, which helps learners understand the complexities involved
Focuses on building a distributed URL shorten service, which provides a practical, real-world application of the distributed systems concepts taught in the course

Save this course

Save Building Modern Distributed Systems with Java to your list so you can find it easily later:
Save

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Building Modern Distributed Systems with Java with these activities:
Review Distributed Systems Fundamentals
Solidify your understanding of core distributed systems principles before diving into the course's specific technologies.
Browse courses on Distributed Computing
Show steps
  • Review basic concepts like CAP theorem and consistency models.
  • Study common distributed system architectures.
  • Practice with simple distributed system examples.
Read 'Designing Data-Intensive Applications'
Gain a deeper understanding of the principles behind distributed systems and data management.
Show steps
  • Read the chapters relevant to the course topics.
  • Take notes on key concepts and design patterns.
  • Relate the book's content to the course material.
Implement Consistent Hashing
Reinforce your understanding of consistent hashing by implementing it in Java.
Show steps
  • Choose a suitable hash function.
  • Implement the consistent hashing algorithm.
  • Test the implementation with different data sets.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Write a Blog Post on Service Mesh
Solidify your understanding of service meshes by explaining the concept in a blog post.
Show steps
  • Research different service mesh implementations.
  • Explain the benefits and drawbacks of using a service mesh.
  • Publish the blog post on a platform like Medium or personal blog.
Build a Simple Distributed Key-Value Store
Apply the concepts learned in the course by building a practical distributed system.
Show steps
  • Design the architecture of the key-value store.
  • Implement the core functionalities, including data replication and consistency.
  • Test the system for scalability and fault tolerance.
Read 'Kafka: The Definitive Guide'
Deepen your knowledge of Apache Kafka and its role in distributed systems.
Show steps
  • Focus on the chapters related to Kafka's architecture and use cases.
  • Experiment with the code examples provided in the book.
  • Consider how Kafka can be integrated into the distributed URL shortener project.
Contribute to an Open-Source Cassandra Project
Gain practical experience with Apache Cassandra by contributing to an open-source project.
Show steps
  • Find an open-source project that uses Cassandra.
  • Identify a bug or feature to work on.
  • Submit a pull request with your changes.

Career center

Learners who complete Building Modern Distributed Systems with Java will develop knowledge and skills that may be useful to these careers:
Distributed Systems Engineer
A Distributed Systems Engineer designs, develops, and maintains large-scale distributed systems. The complexities of building systems that can handle massive amounts of data and traffic require a deep understanding of distributed computing principles. This course addresses challenges that arise while designing and implementing such systems, offering insights into solutions employed by Big-Tech companies. This course covers service registry and discovery, Apache Cassandra, ETCD, Apache Kafka, idempotent service design, sharding, consistent hashing, load balancing, and more. Someone aspiring to be a Distributed Systems Engineer should take this course to learn the practical aspects of building robust and scalable distributed applications.
Software Architect
A Software Architect makes high-level design choices and dictates technical standards, including software coding standards, tools, and platforms. Given the increasing reliance on distributed systems, a Software Architect need to understand the technologies and algorithms involved. This course explores service registry and discovery, service meshes, distributed databases, and messaging systems. Understanding the principles of distributed systems design, such as master-less versus with leaders, helps a Software Architect make informed decisions. This course provides a practical look at distributed systems, equipping Software Architects with the knowledge to design effective and scalable solutions.
Backend Engineer
A Backend Engineer is responsible for the server-side logic and databases that power applications. This often involves working with distributed systems to ensure scalability and reliability. This course dives deep into technologies like Apache Cassandra, Apache Kafka, and ETCD, which are essential for building modern backend systems. Learning about idempotent service design and retry logic, as is done in this course, provides a strong foundation for building robust backend services. This course teaches the principles of distributed systems design, which is invaluable for Backend Engineers aiming to build high-performance applications.
DevOps Engineer
A DevOps Engineer focuses on automating and streamlining the software development lifecycle, often working with distributed systems for deployment and monitoring. This course introduces concepts like canary deployment, sidecar patterns, and circuit breakers, which are crucial for managing and deploying distributed applications. Moreover, the course's coverage of cluster coordination using tools like ETCD, an important tool for managing Kubernetes clusters, will be particularly relevant. A DevOps Engineer can use this course to improve their understanding of distributed systems deployment and management.
Data Engineer
A Data Engineer builds and maintains the infrastructure required for data storage, processing, and analysis, often involving distributed databases and messaging systems. This course covers Apache Cassandra and Apache Kafka, which are widely used in data engineering pipelines. Understanding data sharding and consistent hashing, key topics in this course, is essential for building scalable data platforms. Furthermore, coverage of distributed messaging systems will be helpful. This course can enhance a Data Engineer's ability to design and implement efficient data processing systems.
Systems Architect
A Systems Architect designs and oversees the implementation of complex computer systems, often involving distributed components. An understanding of challenges in distributed computing and solutions employed by Big-Tech companies is invaluable for this role. This course will be helpful in understanding service registry and discovery, service meshes, distributed databases, and messaging systems. This course provides Systems Architects with the knowledge needed to make informed decisions about the architecture of distributed systems.
Cloud Architect
A Cloud Architect designs and implements cloud computing solutions. Because cloud environments are inherently distributed, understanding distributed systems principles is crucial. This course focuses on challenges in designing and implementing large-scale distributed systems, covering technologies like Apache Cassandra, Apache Kafka, and ETCD. Learning about concepts like service registry and discovery is relevant since they are often used in cloud-native architectures. This course may improve a Cloud Architect's ability to design scalable and robust cloud-based applications.
Technical Lead
A Technical Lead guides a team of developers and is responsible for the technical direction of projects. This course emphasizes challenges in designing and implementing large-scale distributed systems, and how big tech companies solve these problems, is useful. Learning about technologies like Apache Cassandra, Apache Kafka, and ETCD provides a solid foundation for leading technical discussions and making architectural decisions. This course may enhance a Technical Lead's ability to guide their team in building effective distributed solutions.
Solutions Architect
A Solutions Architect designs and implements solutions to business problems using technology. With the increasing prevalence of distributed systems in enterprise environments, this course provides a basis for building effective solutions. This course discusses challenges in designing and implementing large-scale distributed systems, covering topics such as service registry and discovery. This course may equip a Solutions Architect with the knowledge to design and implement distributed solutions.
Database Administrator
A Database Administrator is responsible for maintaining and optimizing databases. With the rise of NoSQL databases and distributed database systems, understanding the principles of distributed data management is increasingly important. This course covers Apache Cassandra and the concepts of data sharding and consistent hashing. This course may be valuable for Database Administrators looking to expand their knowledge of distributed database technologies.
Site Reliability Engineer
A Site Reliability Engineer ensures the reliability and performance of systems, often working with distributed applications. Concepts like circuit breakers, client-side load balancing, and distributed tracing, are covered in this course, and are relevant to this role. This course may help a Site Reliability Engineer understand how to build and monitor distributed systems for optimal performance.
Security Engineer
A Security Engineer focuses on protecting computer systems and networks from threats. Distributed systems introduce unique security challenges, and understanding the underlying technologies is important for mitigating risks. This course covers various aspects of distributed systems design and implementation, which may offer insights into potential vulnerabilities and security best practices. Security Engineers may find this course useful in enhancing their skill set.
Application Developer
An Application Developer designs and builds software applications. While not always directly involved in distributed systems design, understanding how applications interact with distributed services can be beneficial. This course covers remote procedure calls and messaging systems, which are relevant for building applications that communicate with backend services. Application Developers may find this course beneficial to understanding building modern applications.
Network Engineer
A Network Engineer designs, implements, and manages computer networks. While this role is primarily focused on network infrastructure, understanding how distributed systems rely on networks can be helpful. This course covers concepts related to communication patterns and load balancing. Network Engineers may find this course helpful.
Technical Consultant
A Technical Consultant advises clients on technology solutions. With many companies adopting distributed systems, understanding the technologies and challenges involved can be very useful. This course provides knowledge about distributed systems design and implementation, covering topics like service registries and distributed databases. Technical Consultants may find this course helpful.

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Building Modern Distributed Systems with Java.
Provides a comprehensive overview of the challenges and solutions in building reliable, scalable, and maintainable data systems. It covers many of the topics discussed in the course, such as data storage, replication, consistency, and distributed transactions. It serves as an excellent reference for understanding the underlying principles behind the technologies covered in the course. This book is commonly used as a textbook at academic institutions.
Provides a comprehensive guide to Apache Kafka, covering its architecture, design principles, and use cases. It is particularly useful for understanding the distributed messaging systems aspect of the course. It provides practical examples and best practices for using Kafka in real-world applications. This book is commonly used by industry professionals.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser