Advanced Programming Course

Lesson 1 • Version Control with Git

Introduces Git workflows essential for collaborative and solo advanced projects. Students commit, branch, and merge confidently by section end.

Lesson 2 • Core Programming Concepts Review

Revisits variables, data types, and operators as the baseline for advanced work. Ensures uniform conceptual grounding before introducing complex patterns.

Lesson 3 • Control Flow and Error Handling

Examines conditionals, loops, and structured exception handling as building blocks for robust programs. Connects directly to defensive coding practices used throughout the course.

Lesson 1 • Non-Linear Data Structures

Explores trees, heaps, and graphs as structures for hierarchical and relational data. Students implement traversal and search algorithms on each structure.

Lesson 2 • Linear Data Structures

Covers arrays, linked lists, stacks, and queues with implementation trade-offs. Provides the structural vocabulary needed for all subsequent algorithm work.

Lesson 3 • Hash Tables and Collision Resolution

Examines hash function design and collision strategies for O(1) average-case lookups. Connects to real-world caching and indexing scenarios introduced later.

Lesson 4 • Algorithm Complexity Analysis

Teaches Big-O, Big-Theta, and Big-Omega notation for rigorous performance reasoning. Students annotate their own code with complexity proofs.

Lesson 1 • Design Patterns: Creational

Covers Factory, Builder, Singleton, and Prototype patterns with use-case rationale. Students implement each pattern and identify misuse anti-patterns.

Lesson 2 • Design Patterns: Structural and Behavioral

Examines Adapter, Decorator, Observer, and Strategy patterns as solutions to recurring design problems. Students select patterns based on change-axis analysis.

Lesson 3 • SOLID Principles in Practice

Applies each SOLID principle to realistic code samples with before-and-after comparisons. Builds the judgment needed to evaluate design quality in code reviews.

Lesson 4 • Encapsulation and Abstraction

Defines information hiding and interface-based design as tools for reducing coupling. Students redesign leaky APIs to enforce proper access boundaries.

Lesson 1 • Monads and Functional Error Handling

Introduces Maybe, Either, and Result types as composable error-handling abstractions. Students replace nested null checks with monadic pipelines.

Lesson 2 • Closures and Lexical Scope

Explains how closures capture environment and enable stateful functional patterns. Students debug common closure pitfalls in loop and async contexts.

Lesson 3 • Higher-Order Functions

Covers map, filter, reduce, and function composition as primary data-transformation tools. Connects to pipeline architectures introduced in later chapters.

Lesson 1 • Reactive and Event-Driven Patterns

Introduces observable streams and backpressure as tools for composable async workflows. Students build a reactive pipeline handling variable-rate data sources.

Lesson 2 • Concurrent Data Structures

Examines lock-free queues, concurrent hash maps, and atomic operations for contention reduction. Connects to high-performance service design in later chapters.

Lesson 3 • Async/Await and Promises

Teaches promise chaining and async/await syntax for non-blocking I/O operations. Students convert callback-heavy code to clean async pipelines.

Lesson 4 • Threads and Process Models

Contrasts thread-based and process-based concurrency with scheduling implications. Establishes the mental model needed for all subsequent concurrency topics.

Lesson 1 • Scalability and Reliability Patterns

Teaches load balancing, circuit breakers, and bulkhead isolation for fault-tolerant services. Students apply patterns to a reference architecture under simulated failure.

Lesson 2 • Architecture Decision Records

Formalizes the process of documenting design choices with context, options, and consequences. Students produce ADRs for every major decision in their capstone project.

Lesson 3 • API Design and Contract-First Development

Covers RESTful principles, GraphQL schemas, and gRPC contracts as interface design tools. Students write API specifications before implementation to enforce contract discipline.

Lesson 4 • Architectural Styles Overview

Surveys monolithic, layered, microservices, and event-driven styles with trade-off matrices. Provides the vocabulary for all subsequent design decisions in the course.

Lesson 1 • Static Analysis and Code Review

Applies linters, type checkers, and structured review checklists to enforce quality gates. Students conduct peer reviews using a rubric derived from SOLID principles.

Lesson 2 • Performance and Load Testing

Introduces profiling, benchmarking, and load simulation to identify bottlenecks before production. Students correlate profiler output with architectural decisions.

Lesson 3 • Integration and End-to-End Testing

Covers contract testing, database integration tests, and UI automation for full-stack validation. Students design a test pyramid balancing speed and confidence.

Lesson 4 • Unit Testing Fundamentals

Establishes test structure, assertion libraries, and the Arrange-Act-Assert pattern for isolated tests. Students retrofit tests onto legacy code using dependency injection.

Lesson 1 • Memory Management and Optimization

Examines garbage collection tuning, object pooling, and memory leak detection for low-latency systems. Students reduce heap allocation in a provided high-throughput service.

Lesson 2 • Advanced Design Patterns

Introduces CQRS, event sourcing, and saga patterns for complex domain and distributed scenarios. Students implement an event-sourced aggregate with full replay capability.

Lesson 3 • Parallel and Distributed Computing

Applies data parallelism, task parallelism, and MapReduce patterns to large-scale computation. Students partition a batch job across worker nodes and measure speedup.

Lesson 4 • Caching Strategies

Covers in-process, distributed, and CDN caching with invalidation policies for each tier. Students implement a multi-tier cache and measure hit-rate improvements.