ECE 465 Spring 2026: Master Course Notes Compilation
<- back to syllabus
This document serves as the global synthesis of all lecture materials and design deep-dives covered throughout the semester. Follow the links provided within each section to access the detailed, technical notes for that week.
Classes will be decided week-to-week.
| Week(s) |
Week of |
Topic |
| 01 |
1/27 |
Intro; centralized vs distributed systems; development environment setup |
| 02 |
2/3 |
Multi-processing & network programming — Part 1 |
| 03 |
2/10 |
Multi-processing & network programming — Part 2 |
| 04 |
2/17 |
Multi-processing & network programming — Part 3 |
| 05 |
2/24 |
Containerization: Docker and Kubernetes |
| 06 |
3/3 |
DevOps and CI/CD |
| 07 |
3/10 |
Integrate application to infrastructure |
| 08 |
3/17 |
Distributed Architectures |
| 09 |
3/24 |
Communication and Coordination |
| 10 |
3/31 |
Consistency & Replication |
| 11 |
4/7 |
Fault Tolerance |
| 12 |
4/21 |
Security |
| 13 |
4/28 |
Deploying on k8s on cloud-based virtual bare metal nodes |
| 14 |
5/5 |
Deploying on k8s on cloud-based k8s |
| 15 |
5/12 |
Final individual projects due |
Follow the link above to the respective week’s materials below.
- Overview: An introduction to defining exactly what a distributed system is—a collection of autonomous computing elements that appears to its users as a single coherent system.
- Key Concepts: The difference between highly decentralized structures versus physically distributed ones, and the four core design goals: Resource Sharing, Distribution Transparency, Openness, and Scalability.
- Overview: A deep dive into the foundational operating system constructs required to build distributed logic.
- Key Concepts: Understanding the Linux Process model, context switching overheads, and Inter-Process Communication (IPC) utilizing pipes, shared memory, and locks. Contrastingly, the transition to multi-threading within a shared address space is explored with Python and Java examples to achieve lightweight concurrency.
- Overview: Expanding upon basic intra-machine multiprocessing to inter-machine communication over standard network protocols.
- Key Concepts: Establishing reliable byte streams via TCP sockets and unreliable packet transmission via UDP. Moving from theoretical concurrency models to physical Java networking implementations.
- Overview: Elevating raw byte-stream communication into the high-level paradigms needed for modern distributed application development.
- Key Concepts: Remote Procedure Calls (RPC) that marshal parameters to make remote executions appear local, and Message-Oriented Communication (Message Queues, Publish-Subscribe topologies) to totally decouple senders from receivers and provide asynchronous resilience.
- Overview: Exploring how to predictably package, deploy, and scale complex, multi-service network applications.
- Key Concepts: Bridging the theory of OS-level virtualization to practice via Docker containers. Investigating declarative orchestration utilizing Kubernetes/Docker Compose. A massive real-world implementation is detailed here: building a distributed Image Processing Map-Reduce framework using a containerized microservice topology.
- Overview: The automation journey from manual configuration to reliable, automated code deployments.
- Key Concepts: Analyzing the DevOps culture shift and API-first designs. Building Continuous Integration (CI) pipelines for build/test testing alongside Continuous Deployment (CD) progressive delivery models (Rolling, Blue-Green, Canary). Integrating GitOps and Infrastructure as Code into modern cluster deployments.
- Overview: Examining how disparate applications are bridged smoothly to underlying OS and network infrastructure.
- Key Concepts: The definition and utility of Middleware as a single-system image enabler. Deep exploration of application integration using Wrappers, Adapters, and Interceptors. The accompanying design exercise challenges students to implement a robust routing and logging proxy interceptor in raw code.
- Overview: Analyzing the fundamental logical and physical layouts of distributed environments, aligning directly with Tanenbaum’s Chapter 2.
- Key Concepts: Decoupling Architectural Styles (Layered, Object-based, Resource-centered/REST, Event-based) from System Architectures (Centralized client-server topologies vs Decentralized structured P2P vs Hybrid Edge/Cloud computing).
- Overview: An exploration of how distributed applications actually pass messages and synchronize state across physical networks without failing.
- Key Concepts: The nuances of Remote Procedure Calls (RPC) versus socket-level message passing. The theory behind logical Lamport clocks, leader election via the Ring and Bully algorithms, and achieving scalable fault-tolerance. The week culminates with deploying a live, event-driven Homogeneous MapReduce engine backed natively by Apache ZooKeeper and Kubernetes.
- Overview: An investigation into the inherent tradeoffs between data reliability and latency when deploying active cluster network replicas.
- Key Concepts: Contrasting Data-Centric consistency models (Strict, Sequential, Causal, Eventual) against Client-Centric session guarantees (Read-Your-Writes). We advance the infrastructure constructed in Week 09 to natively deploy Python ZooKeeper scripts modeling Eventual Convergence, synchronous Primary-Backup replication, and mathematically provable N-W-R Quorum-based transaction partitions.
- Overview: Designing systems that can withstand failures of individual components.
- Key Concepts: Analyzing failure models (e.g., crash failures, Byzantine failures) and implementing fault-tolerant mechanisms such as redundancy, checkpointing, and recovery protocols. The week delves into practical techniques for building resilient distributed systems.
- Overview: Securing distributed systems against various threats.
- Key Concepts: Exploring security fundamentals including authentication, authorization, and encryption. The week covers secure communication protocols, access control mechanisms, and best practices for securing distributed applications.
- Overview: Practical deployment of Kubernetes on bare metal infrastructure.
- Key Concepts: Hands-on experience with deploying Kubernetes clusters on cloud-based virtual bare metal nodes. The week covers cluster setup, node provisioning, and managing workloads in a bare metal environment.
- Overview: Advanced Kubernetes deployment strategies on managed cloud services.
- Key Concepts: Deep dive into deploying and managing Kubernetes on cloud-based managed Kubernetes services. The week covers cluster scaling, monitoring, and leveraging cloud-specific features for enhanced performance and reliability.
- Overview: Final project presentations and submission.
- Key Concepts: Students present their individual projects, demonstrating their understanding of distributed systems concepts and practical implementation skills. This week serves as a capstone for the course, showcasing the culmination of the semester’s learning.
<- back to syllabus