Teaching
Computing
Differently.
Six courses built on one conviction: students learn CS best when they build real things, earn abstractions through struggle, and understand that every algorithm encodes a set of values about the world. No exams. No required textbooks. Every concept earned by building. A proposal in development — not a currently taught program.
This Week
Restructuring teach_cs as a working dashboard, and scoping the HelpMap protocol with Jeff Anderson.
Full logShipped per-course OG image generation so sharing /courses/cs180-intro-ai now renders a branded card with the course number and accent color. Same iteration also added a global focus-visible ring, skip-to-main link, ARIA roles for course detail tabs (with arrow-key nav), an active-page highlight in the navbar, and an EducationalOrganization JSON-LD block on the homepage. The site is now keyboard-navigable end to end and shareable on a per-course basis.
Added /log as a single chronological surface for what I'm reading, building, and figuring out. The goal is twofold: develop a weekly capture habit, and give Jeff Anderson a single URL to bookmark for visible progress. The format is intentionally minimal — a TypeScript file I edit and push. No CMS, no markdown processor, no friction. If a thought is worth ten minutes of writing, it lives here.
The Problem This Curriculum Addresses
Most introductory CS courses follow the same pattern: explain a concept, demonstrate syntax, assign practice problems, assess on recall. Students who arrive with prior exposure tend to succeed. Students who don’t fall behind quickly and conclude they are not a CS person. The course then calls this selection, when in fact it is structure. The difficulty students experience in introductory CS is not uniformly about ability— most of it is caused by courses that teach abstractions before problems, syntax before meaning, and efficiency before understanding.
How These Courses Are Built
Three pedagogical principles run through every course in this curriculum. They are not buzzwords — each one is a concrete design decision that shows up in how units are sequenced, how projects are scoped, and how student work is assessed. Each principle traces to a specific body of learning science research.
Every major concept is introduced through a problem that requires it — before the formal tool is offered. This is Guershon Harel’s intellectual need principle: students must experience the inadequacy of what they currently have before a new tool will feel like a solution rather than a fact to memorize. A hash table isn’t defined on day one. Students first build a slow lookup system, hit the wall of its inefficiency, and then the hash table arrives as the answer to a question they already have.
Students implement every major data structure and algorithm from scratch before using the library version. This is not hazing — it is the difference between knowing that sklearn has a fit() method and understanding what fitting means. Ko’s read-before-write research shows that students who trace implementations before writing them develop significantly stronger debugging ability and conceptual transfer. Every abstraction has an interior; students earn the right to ignore it by first understanding it.
The social implications of algorithmic systems are not a lecture added at the end of the semester — they are woven into the technical content from the start. When students build a word frequency analyzer, they ask whose vocabulary the default dictionary centers. When they study PageRank, they ask what gets amplified and what gets buried. This is not politics inserted into CS. It is the recognition that every algorithm encodes the values of the people who built it — and understanding those values is part of understanding the algorithm.
Six Courses
Each course is a complete 18-week experience: a central project arc, three entry tracks for students at different levels, portfolio-based assessment, and a public exhibition at semester end. No exams. No required textbook purchases. All course materials free and open access.
Every course starts from Track I — no prior programming required. The engineering branch (Math 2B, ENGR 11) is a parallel track for students taking applied linear algebra alongside the CS sequence.
Artificial Intelligence
AI is not magic — it is math, history, and human choice. We build from first principles: probability, search, neural networks, language models. Then we ask who built these systems, for whom, and what they’re encoding about the world.
Machine Learning
ML algorithms are not neutral mathematical facts — they are choices about what to optimize, whose data counts, who bears the error. We derive every algorithm before using it, implement from scratch before touching any library.
& Algorithms
Every data structure is an argument about the world. Every algorithm is a strategy, a tradeoff, a value judgment. We implement every structure before using the library version. No LeetCode grind culture — deep projects that transfer.
Work
PageRank. GPS. The phone in your pocket. Three technologies derived from first principles. You’ll understand why they work — not just that they work. Includes the signature project: Build a Computer from Scratch — a 20-week team build of an 8-bit breadboard computer bridging five STEM disciplines.
Algebra
Six fundamental problems. Twenty-nine lessons. Build circuits, collect data, verify models. Derive before compute — the ALAF approach. Math made useful the moment it’s introduced.
Problem Solving
Model real circuits. Understand why 0.1 + 0.2 ≠ 0.3. MATLAB the way engineers use it — from binary representation up to IEEE 754 floating-point. No prior programming required.
Three Tracks
Every course in this curriculum is designed to run at three simultaneous depth levels. These are not ability groups, remediation tiers, or ceiling categories — they are depth choices. The same concept is offered to everyone. What varies is whether a student builds it, proves it, or extends it. Track I is a complete, serious course outcome — not a consolation.
Students develop genuine working fluency with the core concept. They build a complete, functional implementation and can explain what it does and why. No prior experience required at Track I — by design.
Students implement the concept rigorously, handle edge cases, and extend it to a novel context. They move between their own implementation and a library version and explain the tradeoffs in writing.
Students engage with the formal mathematical structure of the concept, read related research, and contribute something original — a proof, an optimization, a novel application, or a written critical analysis.
Signature Projects
These are not homework assignments with a twist. Each signature project is the central learning experience of its unit — designed so that students encounter the core concept as a genuine problem to solve, not a technique to apply. Every project is public: presented at a semester-end exhibition open to the campus community.
Teams of students build a working, programmable 8-bit computer on breadboards from logic gates — and in the process encounter the physics, mathematics, linear algebra, differential equations, and chemistry that make it possible. Inspired by Ben Eater. Grounded in seven bodies of learning science research. Designed for cross-STEM transfer.
Students build a functional contacts application — adding, searching, sorting — starting with a flat list. As the dataset grows, they measure slowdown empirically, identify the bottleneck, and redesign. The project runs four weeks, and students implement and profile at least three structural approaches before semester end.
Students implement linear regression, logistic regression, and a single-layer neural network entirely in NumPy — no sklearn allowed until the implementation is complete. The final submission includes both versions plus a written explanation of what the library conceals and why that matters.
Students choose a real, deployed AI product — a hiring tool, content moderator, facial recognition API, or recommendation system — design a structured test protocol, run it, measure performance across demographic groups, and produce a findings report structured like a research paper. Directly adapted from Buolamwini’s Gender Shades methodology.
Students derive the PageRank algorithm from the random surfer model, implement it on a graph of their own construction, then run it on a real web crawl. They modify the damping factor and adjacency structure and observe how rankings change — which leads directly to the question of who decides what matters on the internet.
Every capstone project must include a written explanation addressed to a non-technical family member: what does your program do, what problem does it solve, and why should someone care? If you cannot explain it to someone who doesn’t speak code, you don’t fully understand it yet. Communication is assessed alongside the code itself.
Every course ends with a public exhibition, not a final exam. Students present their portfolio of work to an audience of peers, instructors, and community members. Students write a self-evaluation against the course learning goals and propose their final grade with evidence from their portfolio.
Research Roots
These courses are not built on personal teaching preference. Each design decision traces to a body of research or a theoretical framework. The thinkers below are not name-dropped — their ideas show up in specific assignments, assessment structures, and sequencing decisions across every course in this curriculum.
Equitable, joyous computing education. Read-before-write sequencing. Student agency and institutional trust as preconditions for learning.
Jeff’s top-level professional goal: use antiracist learning science to help people thrive. He maps every classroom decision back to research in cognitive science, the psychology of learning, and the scholarship of anti-racism. Creator of the ALAF textbook, the Strategic Deep Learning framework, five anti-racist learner-centered objectives, and a pioneering ungrading practice.
Students are not empty vessels to fill with content. The banking model of education reproduces passivity. Knowledge is a liberatory act when connected to lived experience.
The classroom as a site of freedom. Bringing the full self to learning. The instructor’s vulnerability and intellectual engagement as pedagogical tools.
The coded gaze. Facial recognition systems that fail disproportionately on darker-skinned women. Bias is not accidental — it is the product of who is in the room when systems are built.
Search engines encode power. Information retrieval systems reflect and amplify the values of the people and institutions that build and fund them.
The New Jim Code: technological systems that discriminate while claiming objectivity, making discrimination harder to name and challenge.
Algorithms are art. Rigor and beauty are not opposites. The deep analysis of even simple algorithms reveals structure that cannot be seen from the surface.
About This Curriculum
Designed by Henry Fan — CVC-OEI Application Support Analyst at FHDA, CS curriculum designer, and mentee of Prof. Jeff Anderson (Foothill College). The framework is a proposal, not a currently taught program.
Full About