Work with bits, bytes, binary numbers, text encodings, images, audio, and compression. This gives you the vocabulary to reason about what data really is inside a machine.

Use true/false values, logic gates, conditions, and truth tables to model decisions. These ideas connect everyday rules to circuits, code, databases, and security checks.

Turn ordinary tasks into clear procedures with inputs, outputs, steps, and edge cases. You will write and test simple algorithms before using a programming language heavily.

Follow the major shifts from mechanical calculators and mainframes to personal computers, the internet, open source, cloud computing, mobile devices, and AI systems. The goal is to see why today’s tools, institutions, and tradeoffs look the way they do.

Set up a working environment with a text editor, terminal, folders, package tools, and basic shell commands. You will create, run, move, inspect, and organize small programs from the command line.

Write programs using values, variables, expressions, conditionals, loops, and input/output. The focus is small working programs that solve concrete problems and fail in predictable ways.

Break programs into functions with parameters, return values, local state, and reusable modules. You will practice turning repeated code into named pieces that are easier to test and change.

Find and fix mistakes with error messages, print tracing, debuggers, stack traces, and careful reproduction steps. You will also handle expected failures instead of letting programs crash mysteriously.

Read and write text files, CSV, JSON, and simple configuration files. This chapter turns programs from isolated exercises into tools that can process real stored information.

Use arrays, strings, indexing, slicing, traversal, and common transformations. You will solve practical problems such as cleaning text, summarizing lists, and detecting duplicates.

Model real things with records, objects, references, and nested data. You will represent users, orders, documents, game entities, and other structured information without losing track of identity and mutation.

Use classes, methods, encapsulation, composition, and inheritance where they help manage growing programs. You will design small object models and compare them with simpler data-and-function designs.

Use immutability, pure functions, higher-order functions, mapping, filtering, reducing, and composition. This style improves reasoning about data transformations and prepares you for many modern languages and data tools.

Build the math toolkit behind computing: sets, relations, functions, counting, modular arithmetic, graphs, and induction. Each topic is tied to programming examples rather than treated as distant theory.

Reason about whether programs and algorithms are correct using preconditions, postconditions, loop invariants, examples, counterexamples, and small proofs. This chapter trains the habit of proving claims instead of only hoping tests pass.

Use probability, distributions, sampling, descriptive statistics, correlation, uncertainty, and simple inference. These tools support randomized algorithms, performance measurement, simulation, machine learning, and data analysis.

Measure how algorithms grow with input size using Big O, Big Theta, and Big Omega. You will compare time and memory costs and choose designs that remain usable as data grows.

Implement linked lists, stacks, queues, and deques, then judge when they are better or worse than arrays. The practical work focuses on memory layout, operations, and common interview-style and systems-style uses.

Use hash functions, hash tables, sets, collision handling, and load factors. You will build fast lookup structures and see why hashing is central to databases, caches, compilers, and security.

Work with binary trees, search trees, heaps, tries, and priority queues. You will use them for ordered data, fast minimum or maximum access, prefixes, scheduling, and indexing.

Represent networks of things with vertices, edges, adjacency lists, adjacency matrices, directed graphs, weighted graphs, and graph traversal. Examples include maps, friendships, dependencies, and web links.

Study selection sort, insertion sort, merge sort, quicksort, binary search, and library search/sort behavior. You will connect each algorithm to correctness, runtime, memory use, and practical input patterns.

Solve problems by calling a function on smaller versions of the same problem, trying choices systematically, and storing repeated subproblem results. This chapter covers recursion, backtracking, memoization, and dynamic programming through concrete coding tasks.

Use greedy choice, local improvement, approximation, and constraint thinking for problems where perfect exhaustive search is too expensive. You will practice recognizing when a greedy strategy is valid and when it quietly fails.

Apply breadth-first search, depth-first search, shortest paths, minimum spanning trees, topological sorting, and connectivity algorithms. These tools support routing, planning, build systems, dependency management, and network analysis.

Study finite automata, regular languages, context-free grammars, Turing machines, decidability, and computability. This chapter explains the boundary between problems computers can solve, recognize, or never decide in general.

Classify problems with P, NP, NP-completeness, reductions, and intractability. You will learn when to seek exact algorithms, approximations, heuristics, or a different problem statement.

Build circuits from gates, adders, multiplexers, registers, clocks, and simple datapaths. This connects Boolean logic to the physical structure that executes machine instructions.

Trace how CPUs execute instructions using registers, arithmetic units, control units, instruction sets, and the fetch-decode-execute cycle. You will read simple diagrams that link software behavior to hardware behavior.

Read and write small assembly programs and inspect how high-level code becomes machine instructions. This chapter covers registers, addressing modes, calling conventions, stack frames, and low-level debugging.

Use the memory hierarchy: registers, caches, RAM, virtual memory, disks, and locality. You will see why two programs with the same Big O can perform very differently on real machines.

Study processes, threads, scheduling, context switching, system calls, and kernel/user boundaries. Practical exercises use process inspection tools and small programs that start and coordinate other programs.

Work with virtual memory, paging, address spaces, allocation, garbage collection, and memory safety. You will connect crashes, leaks, segmentation faults, and performance problems to how memory is managed.

Use files, directories, permissions, buffering, disks, SSDs, and file-system metadata. You will reason about durability, corruption, backups, and why storage is slower and trickier than memory.

Write programs that do multiple things at once using threads, locks, semaphores, futures, async I/O, and message passing. You will diagnose races, deadlocks, starvation, and coordination bugs.

Build the core model of networks: hosts, links, packets, latency, bandwidth, routing, ports, sockets, and layered protocols. You will use command-line tools to inspect real network behavior.

Work with IP, TCP, UDP, DNS, TLS, NAT, and routing at the level needed by programmers and system designers. This chapter explains how data moves across the internet and where failures commonly occur.

Use URLs, HTTP methods, headers, status codes, cookies, caching, browsers, and web servers. You will trace a full web request from click to response and build small HTTP services.

Model data with tables, keys, relationships, constraints, normalization, and schema design. You will design relational databases that protect data integrity instead of relying only on application code.

Write SQL queries with filtering, joins, grouping, aggregation, subqueries, updates, and deletes. Practical work centers on answering real questions from messy but structured data.

Use indexes, query plans, transactions, isolation levels, locking, and ACID guarantees. You will tune slow queries and reason about what can go wrong when many users change data at the same time.

Use key-value stores, document databases, wide-column stores, graph databases, and distributed data tradeoffs. This chapter focuses on when non-relational designs fit the access pattern better than a single relational schema.

Study syntax, semantics, types, scope, evaluation, memory models, and language tradeoffs. You will compare languages by the problems they make easy, the errors they prevent, and the costs they impose.

Build the main stages of a compiler: lexing, parsing, type checking, intermediate representation, optimization, and code generation. You will connect formal language ideas to a small working compiler pipeline.

Create and reason about interpreters, virtual machines, bytecode, garbage collectors, and just-in-time compilation. This chapter explains how languages can run without compiling directly to native machine code first.

Design larger programs using modules, interfaces, dependency direction, cohesion, coupling, layering, and architecture patterns. You will practice making codebases easier to change without turning every choice into over-engineering.

Use Git for commits, branches, merges, rebases, pull requests, code review, and release tags. The work mirrors real collaboration where people must change the same codebase safely.

Write unit tests, integration tests, property-based tests, regression tests, and test doubles. You will design tests that catch real failures while staying fast enough for everyday development.

Design APIs with clear resources, contracts, versioning, errors, authentication expectations, and documentation. Practical work includes REST-style services and client code that handles failure well.

Design software around human perception, attention, accessibility, feedback, forms, navigation, and usability testing. You will evaluate interfaces with real tasks rather than personal preference alone.

Follow a real project from problem statement to requirements, design, implementation, tests, review, deployment, documentation, and maintenance. This chapter ties coding, design, collaboration, quality, and delivery into one workflow.

Prevent common implementation flaws such as injection, unsafe deserialization, broken authentication, path traversal, memory bugs, and insecure defaults. You will practice threat-aware coding before attackers or users find the mistakes.

Use symmetric encryption, public-key cryptography, hashing, digital signatures, key exchange, certificates, and random number generation. The focus is correct use and common failure modes, not inventing new cryptosystems.

Analyze firewalls, scanning, vulnerability management, web attacks, denial of service, session security, and incident response basics. You will read attack paths and choose practical defenses for small systems.

Manage authentication, authorization, sessions, secrets, personally identifiable information, consent, retention, and least privilege. This chapter connects privacy promises to concrete data and access-control decisions.

Build systems made of multiple machines using replication, sharding, consensus, leader election, distributed transactions, queues, and failure handling. You will reason about partial failure as a normal design condition.

Package applications with images, layers, registries, container networking, volumes, and runtime isolation. Practical work turns a local program into a repeatable container that runs the same way on another machine.

Automate builds, tests, packaging, security checks, releases, and rollbacks with continuous integration and continuous delivery. This chapter shows how teams reduce manual deployment risk while keeping feedback fast.

Use cloud regions, compute instances, object storage, managed databases, load balancers, identity services, queues, and cost controls. You will design small cloud systems while tracking reliability, security, and spending.

Run containerized applications with pods, deployments, services, ingress, config maps, secrets, autoscaling, and rolling updates. You will see why Kubernetes became a standard layer for operating distributed services.

Build event-driven systems with functions, managed triggers, edge locations, content delivery networks, and globally placed compute. This chapter covers the design tradeoffs of scaling by events and moving work closer to users.

Instrument systems with logs, metrics, traces, dashboards, alerts, and service-level indicators. You will diagnose production failures by following evidence instead of guessing from symptoms.

Protect builds and dependencies with lockfiles, provenance, signing, software bills of materials, vulnerability scanning, and trusted release workflows. This chapter addresses the modern risk that an application is only as safe as its toolchain.

Operate services using service-level objectives, error budgets, incident response, capacity planning, postmortems, and safe rollout practices. You will connect engineering decisions to reliability that users can actually feel.

Move data from sources to usable storage with ingestion, validation, batch processing, streaming, orchestration, warehouses, lakes, and lineage. This chapter prepares you to build data pipelines that other people can trust.

Solve computing problems with floating-point numbers, numerical error, matrices, simulation, and high-performance libraries. You will see why scientific code needs different judgment from ordinary business logic.

Create images with pixels, color, geometry, transformations, rasterization, shaders, lighting, textures, and rendering pipelines. Practical work includes simple 2D and 3D scenes and performance-aware drawing.

Program microcontrollers and small devices with sensors, actuators, interrupts, timers, serial communication, power limits, and real-time constraints. This chapter connects software to physical systems that must react reliably.

Use GPUs, vectorization, kernels, memory transfer, parallel workloads, and accelerator-aware libraries. This chapter explains why modern graphics, simulation, and AI depend on specialized parallel hardware.

Train and evaluate models using features, labels, regression, classification, clustering, decision trees, support vector machines, cross-validation, and metrics. The work emphasizes honest evaluation and knowing when a model is not ready to use.

Model ordered data with trends, seasonality, autocorrelation, forecasting, anomaly detection, and temporal validation. You will handle examples such as traffic, sales, sensor readings, and system metrics.

Build systems that rank and personalize items using collaborative filtering, content-based methods, embeddings, feedback loops, and evaluation metrics. This chapter covers the practical risks of bias, cold starts, and over-optimizing engagement.

Train agents through rewards, policies, value functions, exploration, exploitation, and simulation environments. You will apply reinforcement learning to small control and decision problems before judging where it is practical.

Reason about cause and effect with interventions, confounders, causal graphs, experiments, and observational data. This chapter helps separate “the model found a pattern” from “changing this will produce that result.”

Build neural networks with tensors, layers, activation functions, backpropagation, optimization, regularization, and validation. You will train small models while watching for overfitting, data leakage, and compute limits.

Study attention, positional encoding, encoder and decoder blocks, tokenization, pretraining, and sequence modeling. This chapter explains the architecture that reshaped language, vision, code, and multimodal AI systems.

Work with large pretrained models, prompting, context windows, embeddings, tool use, evaluation, hallucination risks, and deployment constraints. You will treat foundation models as powerful components that need boundaries and verification.

Build retrieval-augmented generation systems with document ingestion, chunking, embeddings, vector search, ranking, prompt assembly, citations, and answer evaluation. This chapter shows how to ground generated answers in external sources.

Adapt pretrained models using supervised fine-tuning, parameter-efficient methods, instruction tuning, data curation, evaluation sets, and safety checks. The focus is deciding when fine-tuning is worth the cost compared with prompting or retrieval.

Generate images, audio, and other media with denoising diffusion, latent spaces, conditioning, guidance, sampling, and evaluation. You will connect the math idea to practical creative tools and their limitations.

Use coding assistants for search, scaffolding, refactoring, tests, documentation, and debugging while keeping human review in control. This chapter covers prompt strategies, verification habits, security risks, and team policies.

Run portable low-level code in browsers, servers, plugins, and sandboxed runtimes with WebAssembly modules, memory, imports, exports, and host interfaces. You will see where WebAssembly fits between native code, JavaScript, and containerized services.

Design tamper-resistant shared ledgers using hashes, signatures, Merkle trees, consensus, smart contracts, wallets, and transaction validation. This chapter separates the computer science of decentralized systems from speculation and hype.

Work with qubits, superposition, entanglement, quantum gates, measurement, simple algorithms, and error correction limits. The goal is enough foundation to read the field clearly and know which problems quantum computing might change.

Connect technical choices to fairness, safety, labor, accessibility, environmental cost, surveillance, misinformation, and accountability. You will practice writing decision records that name harms, stakeholders, tradeoffs, and mitigations.

Build and present a production-style system that includes a user-facing feature, persistent data, tests, security controls, deployment automation, monitoring, and documentation. This capstone forces tradeoffs across the full computer science stack.

Map the field into roles and specialties such as software engineering, systems, security, data, AI, research, product engineering, and infrastructure. You will plan proof-of-skill artifacts, contribution paths, certifications where useful, interview preparation, and habits for staying current.