Skip to content

Exploring Computer Science

The CS theory behind the production code you write.

Exploring Computer Science

Welcome to a practical guide for working engineers who want to understand the computer science foundations underneath the code they ship every day.

The Problem

Your PR got rejected because the reviewer said it's "\(O(n^2)\)". You nodded, made some changes, but couldn't quite explain why the new version is faster. You've debugged stack traces without understanding why they're called "stacks." You use hash tables (Python dict, JavaScript Object) constantly but couldn't explain how they achieve \(O(1)\) lookup.

You know HOW to code. This site teaches you WHY things work.

The Solution

While Exploring Linux, Exploring Python, and Exploring Kubernetes teach practical skills, this site teaches the theory that makes you a stronger engineer. Understand these concepts and you'll:

  • Confidently discuss time/space complexity in code reviews
  • Recognize when your algorithm won't scale
  • Understand what's happening under the hood in your tools
  • Answer theory questions in technical interviews
  • Debug more effectively by understanding fundamentals

How It's Organized

Content is structured by practical value and depth:

  • Essentials

    The CS you need for interviews and understanding performance. Can't call yourself a well-rounded engineer without these.

    What is Computer Science? — The CS theory behind the code you write every day

    Big-O Notation — Why your code is slow and how to talk about it

    Type Systems Basics — The formal contract behind every variable and function signature

    Regular Expressions — The complete syntax reference for writing and reading regex in production code

    Recursion — Divide-and-conquer problem solving from first principles

    Trees — The data structure behind your file system, JSON, and database indexes

    Searching, sorting, stacks, queues (coming soon)

  • Efficiency

    CS that makes you better at debugging and system design. Deeper understanding that pays dividends.

    Computational Thinking — The mental framework behind good engineering

    Finite State Machines — The model behind protocols, parsers, and validation

    Regular Expressions: The Formal Model — How regex engines compile patterns to automata, why backtracking causes ReDoS, and what regex can't match

    How Parsers Work — From raw text to meaning

    Compilers vs. Interpreters — What actually happens between your source code and execution

    Lists as Recursive Structures — The CS theory behind every map, filter, and reduce you've written

  • Mastery

    Deep theory for understanding the limits of computation. For when you want to go beyond practical and into foundational.

    Information Theory — Bits, binary, entropy, and why compression has hard limits

    Recursive Transition Networks — Visual grammars for nested languages

    Backus-Naur Form (BNF) — The notation behind every language specification

    Scheme: A Primer — Lambda, closures, and recursion in the language that invented them

    Higher-Order Functions — How code becomes data

    Scheme & Parse Trees — When code is its own parse tree

    Abstract Data Types — The CS theory behind interfaces, protocols, and traits

    Computability: Turing machines, halting problem, P vs NP (coming soon)

Who This Is For

You're a back-end engineer, platform engineer, or software developer who:

  • Writes production code daily (Python, Go, Java, JavaScript, etc.)
  • Has real-world experience shipping features and debugging issues
  • Lacks formal CS training and wants to fill that gap
  • May be self-taught, bootcamp graduate, or career changer
  • Wants to understand the "why" behind the tools you use

You already know how to code. This site teaches the theory underneath.

Integration with Other Sites

This site is part of the BradPenney.io learning ecosystem:

How they connect:

  • CS site + Python site = Understanding why your code performs the way it does
  • CS site + Tools site = Knowing the theory behind grep (regex), git (DAGs), parsers (compilers)
  • CS site + K8s site = Understanding distributed systems concepts

Ready to understand the theory? Start with What is Computer Science? for context, then Big-O Notation to understand why some code is fast and other code times out at scale.