Computer Science & Systems Engineering Syllabus

MODULE 1: The Foundations of Programming

Focus: Establishing the bedrock of programming logic and algorithmic thinking, learning how a computer reads and executes instructions.

1.1 The First Language (Python)

• Setting up your development environment.
• How variables and data types work in memory (Integers, Floats, Booleans, Strings).
• Basic math operations and string manipulation.

1.2 Control Flow & Logic

• Making decisions with code (if, elif, else).
• Boolean logic and truth tables (AND, OR, NOT).
• Repeating tasks using loops (for and while loops).

1.3 Functions & Code Modularity

• Writing reusable functions to keep code clean.
• Understanding variable scope (Global vs. Local variables).
• Catching errors and preventing crashes (try/except).

MODULE 2: Object-Oriented Programming & Data Structures

Focus: Learning how to organize large codebases and use the right data structures to store information efficiently.

2.1 Object-Oriented Programming (OOP)

• Classes, objects, and constructors.
• The 4 Pillars: Inheritance, Abstraction, Polymorphism, and Encapsulation.
• Understanding the difference between static and instance methods.

2.2 Core Data Structures

• Arrays & Lists: Storing sequences of data and resizing arrays.
• Strings: How text is actually encoded under the hood (ASCII vs. UTF-8).
• Linked Lists: Connecting data using pointers (Singly and Doubly linked).
• Stacks & Queues: Processing data in order (LIFO and FIFO).

2.3 Hash Maps & Fast Lookups

• Dictionaries / Hash Maps: Storing key-value pairs for instant data retrieval.
• Hash Sets: Storing unique items.
• Understanding hash collisions and how to resolve them.

MODULE 3: "Under the Hood" (Hardware & C++)

Focus: Stripping away the safety nets of Python to learn how memory, processors, and manual allocation actually work. This is the core knowledge for systems-level engineering.

3.1 Computer Architecture Basics

• Reading binary and hexadecimal numbers.
• Bitwise math (manipulating 1s and 0s directly).
• How a CPU actually works (Registers, L1/L2/L3 Cache, and RAM).

3.2 Low-Level Language Mastery (C/C++)

• Learning C and modern C++ (C++17/20).
• Pointers, memory addresses, and references.
• Passing data by value vs. passing by reference.

3.3 Manual Memory Management

• The difference between Stack memory and Heap memory.
• Manually allocating and freeing memory (malloc/free, new/delete).
• Identifying Memory Leaks and diagnosing Segmentation Faults.

3.4 Modern C++ Features

• Using the C++ Standard Template Library (STL).
• Using Smart Pointers so memory cleans itself up automatically.

MODULE 4: The Operating System & Command Line

Focus: Surviving in the professional engineering environment, managing concurrent tasks, and tracking code changes.

4.1 Linux & The Terminal

• Navigating the Linux file system and managing permissions (chmod).
• Searching and filtering text in the terminal (grep, awk, sed).
• Writing Bash scripts to automate boring tasks.

4.2 Version Control (Git)

• How Git tracks changes (commits, branches, and merges).
• Branching Strategies: GitFlow vs. Trunk-Based Development.
• Fixing mistakes: interactive rebasing, resolving merge conflicts, and tracking down bugs (git bisect).

4.3 Operating Systems & Concurrency

• The difference between Processes and Threads.
• Virtual Memory and Paging.
• Multithreading: Running multiple tasks at the exact same time.
• Preventing thread crashes (Mutexes, Locks, Deadlocks, and Race Conditions).

MODULE 5: Algorithms & Whiteboard Execution

Focus: The rigorous problem-solving logic required to pass advanced technical whiteboard rounds.

5.1 Time & Space Complexity

• Big-O Notation: Calculating exactly how fast and how much memory an algorithm will take.
• Understanding the tradeoff between using more memory to save time.

5.2 Advanced Data Structures

• Binary Search Trees (BST) and Self-Balancing Trees.
• Tries (Prefix Trees) for autocomplete systems.
• Heaps (Priority Queues) and Graphs (Nodes and Edges).

5.3 Core Algorithmic Strategies

• Searching & Sorting: Binary Search, Merge Sort, Quick Sort.
• Two Pointers & Sliding Window: Efficiently scanning arrays.
• Divide & Conquer: Breaking massive problems into smaller halves.
• Backtracking: Exploring all possible paths (e.g., solving a maze).

5.4 Advanced Optimization

• Dynamic Programming: Saving past results so you don't compute them twice (Memoization and Tabulation).
• Graph Traversal: Breadth-First Search (BFS) and Depth-First Search (DFS).
• Finding the shortest path (Dijkstra's Algorithm).

5.5 The Algorithmic Grind & Metrics

• Language Strategy: Use Python exclusively for interviews because it is fast to write.
• Curriculum: Complete the Blind 75 $\rightarrow$ NeetCode 150 $\rightarrow$ Total goal: 400+ problems on LeetCode.
• Time Target: Solve random "Mediums" in $< \mathbf{25\text{ mins}}$, "Hards" in $< \mathbf{45\text{ mins}}$.

MODULE 6: Enterprise Backend Engineering

Focus: The technology stack that powers massive enterprise databases, public sector web apps, and secure systems.

6.1 Enterprise Languages

• Master Java (Spring Boot) OR C# (.NET Core).
• Structuring code professionally using SOLID principles and Design Patterns.

6.2 SQL Databases & Architecture

• Writing SQL queries, complex Joins, and aggregations.
• Database Indexing (B-Trees) and understanding Query Execution Plans.
• Database Normalization (Organizing tables so data isn't duplicated).
• SQL vs. NoSQL (PostgreSQL vs. MongoDB).

6.3 Building APIs & Web Networking

• The OSI Model and how the internet routes data (TCP/IP).
• Building RESTful APIs and securing them with JWT Authentication.
• Understanding how the backend talks to the frontend (WebSockets, JSON, React basics).

6.4 DevOps & Cybersecurity

• Testing: Writing Unit Tests (JUnit) and practicing Test-Driven Development (TDD).
• Cloud & Deployments: Putting apps in Docker containers and automating deployments (GitHub Actions).
• Security: Stopping the top 10 web hacks (OWASP: SQL Injection, XSS).
• Mandatory Certification: Obtain CompTIA Security+ (Required for DoD/Federal jobs).

MODULE 7: System Design & Applied AI

Focus: Architecting systems that can handle millions of users, and integrating modern AI into applications.

7.1 Scaling Distributed Systems

• Vertical Scaling (buying a bigger server) vs. Horizontal Scaling (buying more servers).
• Using Load Balancers to distribute web traffic evenly.
• Caching data in memory (Redis) so the database doesn't crash.
• Database Sharding and Replication (splitting data across multiple servers).

7.2 Modern Architecture & Monitoring

• Microservices vs. Monolithic architectures.
• Using Message Queues (Kafka, RabbitMQ) to handle massive spikes in traffic.
• Monitoring: Using Prometheus, Grafana, and logs to see exactly when and why a system fails.

7.3 Applied Artificial Intelligence

• Connecting to Large Language Model (LLM) APIs.
• Storing data in Vector Databases (Pinecone, Milvus).
• Building Retrieval-Augmented Generation (RAG) systems so AI can read private enterprise data.

7.4 System Design Practice

• Read: Designing Data-Intensive Applications by Martin Kleppmann (The industry Bible).
• Watch: ByteByteGo (Alex Xu) on YouTube.
• Practice Blueprints: Architecting massive-scale video streaming, global chat apps, and ride-sharing dispatch services.

MODULE 8: The "Proof of Work" Portfolio

Focus: Three undeniable engineering feats that force recruiters to call you.

8.1 Open Source Contributions

• Submit pull requests to major public codebases (Linux, Mozilla, open-source tools) to prove you can navigate massive, messy projects.

8.2 The Three Pillar Projects

1. Project 1 (Systems & Hardware Core): A Multi-threaded C++ Web Server or Physics Engine. (Proves you understand memory, pointers, and hardware).
2. Project 2 (Distributed Cloud Architecture): A Distributed Key-Value Store using Go/Python, Redis, Docker, and Kafka. (Proves you understand scale and algorithms).
3. Project 3 (Enterprise Security & Data): An Enterprise Inventory System using Java/C#, SQL, and strict OWASP security. (Proves you understand business logic and data security).

8.3 Resume Structuring

• Private Sector Tech Resume: 1 page maximum.
• The XYZ Format: Structure every bullet point like this: "Accomplished [X] as measured by [Y], by doing [Z]."

MODULE 9: THE INTERVIEW EXECUTION PLAYBOOK

Focus: How to legally and technically pass the hiring gauntlet for Tier-1 and Government entities.

9.1 Live Mock Interviewing

• Resource: Use Pramp.com or Interviewing.io for live, blind mock interviews with strangers.
• Metric: You are ready when you pass 3 consecutive mock interviews with a "Strong Hire" rating.

9.2 Problem Solving Formulas

• Coding: UMPIRE (Understand, Match, Plan, Implement, Review, Evaluate).
• System Design: PEDALS (Process, Estimate, Design API, Architecture, Look at DB, Scale).
• Hardware/Systems: Expect whiteboarding without a computer. Draw memory diagrams (Stack down, Heap up). Explain out loud how OS threads will lock and unlock your data.

9.3 Behavioral (STAR Method)

• Prepare 7-10 stories: Situation, Task, Action, Result.
• Align with Tier-1 Values: Handling ambiguity, making data-driven decisions, applying first-principles thinking, and demonstrating a continuous growth mindset.

9.4 Government Navigation (USAJOBS & Civil Service)

• Federal Resume: 3-5 pages via USAJOBS Resume Builder. 100% exact keyword mapping of KSAs. List exact hours, credits, and GS grades.
• NYS ITS: Take NYS Civil Service Continuous Recruitment Exams and apply to NY HELPS portal.
• Clearance: Zero illegal drugs (marijuana included), clean criminal record, clean debt for SF-86 background check.

THE 3 DAILY EXECUTION RULES

(To enforce this curriculum without burning out)

1. Code Every Day: Consistency over cramming. 1.5 hours daily is 100x better than 10 hours on a Sunday.
2. Read Documentation: Stop relying on video tutorials. Read the official Python, Java, or C++ documentation. This is the difference between a junior and a senior engineer.
3. Talk Out Loud: When solving algorithmic problems alone in your room, explain your thoughts out loud. Communication is 50% of the interview grade at elite companies.