Teaching
Philosophy
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.
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.
This failure is especially concentrated at community colleges, where students arrive with more diverse prior experience, more financial and time constraints, and less inherited access to the social capital that makes traditional CS culture feel familiar. The typical response — remediation, prerequisite chains, stricter placement — treats the wrong variable.
This curriculum takes a different position: 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. The fix is not remediation. It is a different kind of course — one that begins with a problem the student wants to solve, introduces tools only when they’re needed, and assesses understanding through what students build rather than what they recall.
Three Core Principles
Each principle is a concrete design decision that shows up in how units are sequenced, how projects are scoped, and how student work is assessed. Each traces to a specific body of learning science research.
Derive Before Compute
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 build a linear-search contacts app in Week 2. With 10,000 entries it's unusably slow. Week 4 introduces hash tables — as the solution to a problem students already own.
Harel & Tall (1991) · "The General, the Abstract, and the Generic" · For the Learning of Mathematics
Build Before Import
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.
Logistic regression is implemented in NumPy before scikit-learn is opened. The final submission includes both versions with a written comparison explaining what the library hides.
Ko et al. (2019) · Critically Conscious Computing · University of Washington · cs.washington.edu/ccc
Equity as Design, Not Afterthought
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.
The final project in every AI/ML course is a structured bias audit of a real deployed system — written like a research report and presented at a public exhibition.
Buolamwini & Gebru (2018) · "Gender Shades" · ACM FAccT · Noble (2018) · Algorithms of Oppression
“The most advanced technical skill in these courses is understanding who built a system, for whom, and what it encodes about the world.”
Course Philosophy · Rooted in Freire, hooks, Ko, Anderson
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.
Amy J. Ko
Critically Conscious Computing · UW
Equitable, joyous computing education. Read-before-write sequencing. Student agency and institutional trust as preconditions for learning.
Students trace and read existing implementations before writing their own. Build-before-import is directly drawn from Ko's read-before-write research.
Jeff Anderson
Antiracist Learning Science · Ungrading · Strategic Deep Learning · Foothill College
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. His conviction: the top 100% of learners deserve the best teaching in the world.
Portfolio assessment and student-proposed grading are drawn directly from Anderson's ungrading framework. The Abuelita Test is adapted from his communication frameworks. The three-track system honors his principle that learner-centered means the student determines their path. The Build a Computer project's entire assessment structure, reflection design, and cross-STEM bridging philosophy are built on his foundation.
Paulo Freire
Pedagogy of the Oppressed · 1968
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.
Every capstone is student-chosen and connected to a real problem in the student's community. Students determine what they build, and for whom.
bell hooks
Teaching to Transgress · 1994
The classroom as a site of freedom. Bringing the full self to learning. The instructor's vulnerability and intellectual engagement as pedagogical tools.
Reflective writing is required alongside every project. Students write about struggle, confusion, and discovery — not just what they built.
Joy Buolamwini
Gender Shades · MIT Media Lab
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.
The Bias Audit project in CS 180 and CS 185 is directly modeled on the Gender Shades methodology, adapted for undergraduates with no prior research training.
Safiya Umoja Noble
Algorithms of Oppression · 2018
Search engines encode power. Information retrieval systems reflect and amplify the values of the people and institutions that build and fund them.
The Build PageRank project ends with a structured analysis of how the algorithm's design choices determine whose content surfaces and whose is buried.
Ruha Benjamin
Race After Technology · 2019
The New Jim Code: technological systems that discriminate while claiming objectivity, making discrimination harder to name and challenge.
Benjamin's framework is the theoretical grounding for CS 185: every algorithm is a choice about what to optimize, and that choice has a politics.
Donald Knuth
The Art of Computer Programming
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.
CS 210's emphasis on implementing before using, and on understanding the full analysis of even simple structures, is a direct inheritance from Knuth.