Building Modern Distributed Systems with Java from Udemy

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.

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

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

Traffic lights

Read about what's good

what should give you pause

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

Reviews summary

Modern distributed systems in java

According to learners, this Java course on modern distributed systems is largely positive, proving valuable for experienced developers. Students frequently praise the practical examples, including labs and the URL shortener project, which significantly help solidify understanding. The instructor receives acclaim for providing clear explanations of complex topics like Consistent Hashing and RAFT. However, reviewers caution that the course assumes significant prior knowledge in Java and systems, potentially making it difficult for beginners. Some feedback points to uneven pacing and occasional issues with code examples needing debugging or more detailed explanations. Despite minor criticisms, it's considered a solid course for intermediate/advanced learners and useful for system design interview preparation.

Complex distributed system concepts are clarified.

"The explanations of complex topics like Consistent Hashing and RAFT were clear and easy to follow."

"Excellent deep dive into the fundamentals. The instructor does a great job breaking down difficult ideas."

"Brilliant course! It demystified complex topics in distributed systems."

"The consistent hashing explanation was particularly insightful."

Hands-on labs and coding reinforce learning.

"The practical examples building the URL shortener were incredibly helpful in solidifying the concepts."

"I really appreciated the focus on practical application and design patterns... The lab exercises were well-designed."

"Provides a solid theoretical foundation and practical examples."

"The hands-on practice sessions were fantastic."

Some examples need debugging or clearer step-by-step explanation.

"...the code examples, while present, could be more robust or better explained step-by-step."

"The code examples didn't always work out of the box, and debugging them without more guidance was frustrating."

"The code provided didn't match the lectures sometimes."

Some topics rushed, uneven pace, varying depth.

"The course covers relevant topics, but the pacing is uneven. Some sections feel rushed..."

"Some lectures were very clear, others less so. The assignments were useful but sometimes hard to figure out..."

"...felt some parts, especially around Service Mesh, could have gone into more practical detail..."

Requires strong background, challenging for beginners.

"Requires a strong background in Java and general systems concepts beforehand."

"Found this course quite difficult. Assumes a lot of prior knowledge."

"Beginners might struggle."

"Not recommended if you are new to distributed systems."

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

Show steps

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'

Show steps

Gain a deeper understanding of the principles behind distributed systems and data management.

View Designing Data-Intensive Applications: The Big... on Amazon

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

Show steps

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

Show steps

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

Show steps

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'

Show steps

Deepen your knowledge of Apache Kafka and its role in distributed systems.

View Kafka: The Definitive Guide: Real-Time Data and... on Amazon

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

Show steps

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.

See salaries and explore the career path for Distributed Systems Engineer

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.

See salaries and explore the career path for Software Architect

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.

See salaries and explore the career path for Backend Engineer

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.

See salaries and explore the career path for DevOps Engineer

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.

See salaries and explore the career path for Data Engineer

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.

See salaries and explore the career path for Systems Architect

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.

See salaries and explore the career path for Cloud Architect

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.

See salaries and explore the career path for Technical Lead

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.

See salaries and explore the career path for Solutions Architect

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.

See salaries and explore the career path for Database Administrator

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.

See salaries and explore the career path for Site Reliability Engineer

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.

See salaries and explore the career path for Security Engineer

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.

See salaries and explore the career path for Application Developer

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.

See salaries and explore the career path for Network Engineer

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.

See salaries and explore the career path for Technical Consultant

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.

Designing Data-Intensive Applications

Save

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.

Designing Data-Intensive Applications: The Big...

Paperback

Designing Data-Intensive Applications: The Big...

Kindle Edition

Kafka: The Definitive Guide

Save

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.

Kafka: The Definitive Guide: Real-Time Data and...

Paperback

Building Modern Distributed Systems with Java

What's inside

Learning objectives

Syllabus

Traffic lights

Save this course

Reviews summary

Modern distributed systems in java

Activities

Career center

Reading list

Share

Similar courses

Udemy Buyer Protection & Guarantee

Free Lecture Previews

30-Day Money-Back Guarantee

Verified Academic & Industry Partner