Computer Science & Programming

Browse the Deep Research Index →

Languages covered: Machine code, Assembly, Punch Cards, FORTRAN, ALGOL, Lisp, C, Pascal, C++, Ada, Perl, REXX/ARexx, CLI & Shells, Python, Java, JVM GC, JavaScript/TypeScript, Prolog, Go, Rust. CS concepts: Trace Scheduling & VLIW (Fisher legacy), Service-Oriented Architecture (CORBA to microservices).

Think Like a Computer Before You Code Like One

1. Binary & logic gates. AND, OR, NOT, XOR. Everything a computer does is combinations of these four operations. Build truth tables. Trace circuits. The 555 timer is a logic gate you can hold in your hand.
2. Variables, types, control flow. Store a value. Make a decision (if/else). Repeat something (loops). Every program is data + decisions + repetition.
3. Functions & decomposition. Break a big problem into small pieces. A function is a reusable piece. Composition is building big things from small things. This is the only idea that matters.
4. Data structures. Arrays, maps, sets, trees, graphs. How you organize data determines how fast you can find it. A linked list is a conga line. A hash map is a filing cabinet. A tree is a family tree. A graph is a road map.
5. Algorithms & complexity. Sorting, searching, graph traversal. Big-O notation: how does runtime grow with input size? O(n) = proportional. O(n²) = quadratic (bad). O(log n) = binary search (good). O(1) = hash lookup (best).

The Web Was Born at CERN. Build On It.

1. HTML & CSS. Structure (HTML) and style (CSS). Every web page is a tree of elements with visual rules applied. View source on any page. The web is open by design — thanks to CERN putting it in the public domain in 1993.
2. JavaScript. The language of the browser. DOM manipulation, events, async/await, fetch. Also the language of Node.js (server), Electron (desktop), and React Native (mobile). One language, every platform.
3. HTTP & APIs. GET, POST, PUT, DELETE. Request/response. REST, GraphQL, WebSockets. How browsers talk to servers. How servers talk to each other. How your phone talks to everything.
4. TCP/IP & DNS. The protocol stack: application → transport → internet → link. IP addresses, ports, routing, DNS resolution. How a packet travels from your keyboard to a server and back. Same stack over fiber, WiFi, or ham radio.
5. Databases & state. SQL (PostgreSQL, SQLite), NoSQL (MongoDB, Redis), key-value stores. CRUD operations. Transactions. Indexes. Schema design. Where your data lives when the browser closes.

The Spaces In Between

1. Linux & the command line. The shell is the programmer's workshop. Files, processes, pipes, permissions. Bash scripting. Package management. Every server runs Linux. Every cloud runs Linux.
2. Containers & orchestration. Docker packages your app with its dependencies. Kubernetes runs containers across clusters. Helm charts. Services, pods, ingress. The infrastructure that runs the modern internet.
3. Networking & security. Firewalls, TLS, SSH, VPNs. Load balancers, reverse proxies, CDNs. Certificate management. Zero-trust architecture. Defense in depth.
4. Distributed systems. CAP theorem: you can have two of consistency, availability, partition tolerance. Consensus protocols (Raft, Paxos). Replication. Sharding. The WLCG processes 1 PB/day across 170 sites — that's distributed systems at scale.
5. Monitoring & observability. Logs, metrics, traces — the three pillars. Prometheus, Grafana, OpenTelemetry. SLOs, SLIs, error budgets. You can't fix what you can't see.

The Silicon Under the Software

1. Circuits & Ohm's law. V = IR. Resistors, capacitors, inductors. Series and parallel. The breadboard is your laboratory. A multimeter is your first instrument.
2. The 555 timer. The most popular IC ever made (billions produced). Astable, monostable, bistable modes. PWM, frequency generation, timing. One chip teaches oscillators, comparators, flip-flops, and feedback.
3. Microcontrollers. Arduino, ESP32, Raspberry Pi Pico. Digital I/O, ADC, PWM, I2C, SPI, UART. Read sensors, drive motors, blink LEDs, send data. The bridge between code and physical world.
4. Signal processing. Analog filters (RC, LC), digital filters (FIR, IIR), FFT, sampling (Nyquist). The same math that processes audio also processes sensor data, radio signals, and neural network activations.
5. PCB design & fabrication. Schematic capture, layout, gerber files, assembly. KiCad is free. JLCPCB fabricates boards for $2. From breadboard prototype to manufactured product in a week.

Teaching Machines to Learn

1. Data & statistics. Mean, median, variance, correlation, distributions. Pandas, NumPy. Clean data, visualize data, understand data. Every ML project starts and ends with data quality.
2. Supervised learning. Linear regression, decision trees, random forests, gradient boosting. Training set, test set, validation. Bias-variance tradeoff. Overfitting. Cross-validation. The fundamentals that never go out of style.
3. Neural networks. Perceptrons, backpropagation, activation functions, loss functions, optimizers. PyTorch or TensorFlow. CNNs for images, RNNs for sequences, transformers for everything. The architecture zoo.
4. Large language models. Tokenization, attention, transformer architecture, fine-tuning, prompting, RLHF. The Anthropic API. Claude as a tool, not a replacement. Chain-of-thought faithfulness (our OPEN problems live here).
5. Agent orchestration. Multi-agent systems, tool use, MCP servers, planning, state management. GSD's mayor-coordinator, polecat-worker, witness-observer patterns. WLCG's DIRAC pilot jobs. The future is agents coordinating agents.

Code as Art, Art as Code

1. p5.js / Processing. Draw with code. Shapes, colors, animation, interaction. Our forest simulation is 1,297 lines of p5.js — weather-driven, astronomically accurate, with L-system plants and Physarum slime mold networks.
2. Generative art. L-systems, fractals, noise fields, particle systems, cellular automata. Conway's Game of Life. Langton's ant. The beauty in rules applied recursively.
3. Data visualization. D3.js, Observable, Canvas, SVG. Turn data into insight. Our radar charts, timeline visualizations, and weather dashboards are all hand-coded.
4. Shaders & GPU. GLSL, WebGL, compute shaders. Massively parallel computation. Ray marching, signed distance functions, procedural textures. The GPU thinks differently than the CPU — learn to think in parallel.
5. Interactive simulations. Physics engines, agent-based models, cellular automata. Build a world, set the rules, watch it evolve. Our Kuramoto fireflies, Physarum slime mold, and ecosystem agents are all interactive simulations running in the browser.