Day 1 · the through-line

Humanities & Coding

Why a humanist learns to code

Before we write a single line of code, a question: what do you do with knowledge that can't be measured?

That question is the humanities. Love and grief, justice and beauty, the meaning of a poem or a protest — the things that matter most about being human tend to be exactly the things that resist a number. This course is going to spend eight weeks turning human language into numbers. So let's be honest, on day one, about what that does and doesn't get us.

The human mess

The humanities study the mess of the human condition — and they don't tidy it up. They explore it.

• Contradiction — we hold conflicting values at once; we can love and resent the same person.
• Ambiguity — a text means more than one thing. Is Hamlet mad, or pretending?
• Subjectivity — experience shapes interpretation; beauty and justice look different from different lives.

Many fields look for principles — a law that explains many cases at once. The humanities often do something else: they map the contours of the complexity itself. What one method sets aside as noise is often exactly what we came to study. The poet John Keats called the needed temperament negative capability — being "in uncertainties, mysteries, doubts, without any irritable reaching after fact and reason." Hold onto that phrase; this whole course lives inside it.

So why learn to code?

Here is the productive tension you'll feel all term:

Code wants to categorize, measure, and systematize. Culture is ambiguous, contextual, and messy.

Can a sentiment score capture the nuance of a sarcastic comment? Here is a real one from the file you'll analyze: "If having the 10 commandments on the wall actually worked, we would need to post it in every room in the white house." Hold your guess about how a machine would score it; we'll find out shortly.

What gets lost when we flatten a heated public argument into one average number? Who decides which categories matter when we collect data? These aren't bugs in the software — they're humanities questions, and a humanist is exactly the person equipped to ask them.

So we don't learn to code in order to stop thinking like humanists. We learn it to bring humanities questions to computational methods — to read more voices than one person could ever read by hand, while staying honest about what the counting flattens. That double move — more voices, and no false tidy answer — is the whole course.

What it looks like in the wild

Before the cautions, the payoff — real projects that turn a pile of culture into a pattern you can suddenly see. Start with two that count words much the way you soon will:

• John W. Miller, "Trucks and Beer" — counts what country songs actually sing about (turns out, not just trucks and beer).
• The Pudding, "The Largest Vocabulary in Hip-Hop" — ranks rappers by how many unique words they use in their first 35,000 lyrics. The Wu-Tang chart here is a smaller cut of the same idea: each member's first 3,500 lyrics.

A few more worth a look

No screenshots — these are worth visiting live:

• Every Noise at Once — a navigable map of 6,000+ music genres, drawn from audio analysis. It's no longer being updated, but the map is still there to explore.
• Open Syllabus — maps citations across millions of collected (mostly English-language) syllabi, showing which texts get assigned most often.

Notice the move every one of them makes: a question about people comes first, then the counting. The tool serves the question — never the other way around.

Use the programs, or shape them

Two writers worth hearing on why a humanist bothers with this at all.

The underlying capability of the computer era is actually programming — which almost none of us know how to do. We simply use the programs that have been made for us, and enter our text in the appropriate box on the screen… This means [we] have access to the capabilities given to [us] by others, but not the power to determine the value-creating capabilities of these technologies for [ourselves].

— Douglas Rushkoff, Program or Be Programmed (qtd. in Nick Montfort, Exploratory Programming for the Arts and Humanities, 327–28)

Nick Montfort names the upside just as plainly: learning to code in the humanities lets us think in new ways, understand culture and media systems more deeply, and maybe even help improve society. You don't have to leave here a programmer. But knowing what's inside the box — even a little — is the difference between using the tools that sort our culture and being able to question them.

The score is never the meaning

Look at this diagram. We'll come back to it every week.

It begins much further from "the truth" than you'd guess. At the top sits the noumenon — the philosopher Immanuel Kant's word for a thing as it actually is, the whole lived human fact. A woman in Texas reads that her child's classroom will display the Ten Commandments and feels something complete and entirely her own. We will never have that feeling. What we can have is what she typed — a comment, already a lossy, public projection of an inner state. Those first two steps are hers. Everything after is ours: we scrape it (and some comments are missed), clean it (we choose what counts as a "word"), model it (a sentiment tool looks each word up in a list someone wrote — great counts as +3.1 — and adds up the scores), and only then do we reach for insight, knowledge, and — maybe, by the end — wisdom.

Here is what that does to a real comment. "If having the 10 commandments on the wall actually worked, we would need to post it in every room in the white house" is plainly sarcastic, and plainly critical. None of its words are on the sentiment tool's list, so it scores 0.0: neutral. The other side of the argument gets misread too. "Move out of Texas if you dont want the 10 commandments shown. In God we Trust!" tells opponents to leave, yet it scores +0.67: positive, because the tool counts trust (+2.3) and God (+1.1) as good words. The tool isn't broken. It is doing exactly what it was built to do, which is the problem.

(A note on the diagram. It is this course's own teaching diagram: it extends the familiar data → information → knowledge → wisdom ladder upward, to the experience the data came from. Kant's term is borrowed as an analogy. For Kant the noumenon is unknowable by anyone; here it stands for the lived experience behind a comment, which only its writer had.)

In plainer terms, the stages run: lived experience (noumena) → what people express in public (phenomena) → what we collect (raw data) → what we organize into rows and columns (structured data) → what a method computes from it (analyzed data) → what we make of that (insight, knowledge, wisdom). Three verbs carry us between them. To scrape is to have a program copy text off a web page. To clean is to fix and standardize what was copied. To model is to apply a method that scores, sorts, or groups it.

Every arrow is a choice

Every arrow we draw on that diagram is a human decision — not a neutral pipe, but a choice, with a person and a value behind it. It's tempting to call each step contamination, as if a clean signal up top got dirtied on the way down. But look again: there is no clean signal up top. Even her own words were already an interpretation. Choices aren't what sneak into the data — choices are what the data is made of.

Here is how small a choice can be. Each of these lines counts the word "commandments" in our 93 comments:

comments_text.count("commandments")           # 13
comments_text.lower().count("commandments")   # 25
comments_text.lower().count("commandment")    # 27

The first misses every "Commandments" with a capital C — like "Doesn't matter if they post the Ten Commandments or not." The second lowercases the text first. The third also catches the singular, as in "broken every Commandment except for Honor Thy Father and Mother." None of them is wrong, and none of them is the count. Someone has to decide.

That's not cause for despair, and it's not a reason to distrust everything. It's the reason for the one habit this course asks of you constantly: make your choices visible. Every time you delete a word, set a threshold, or name a topic, you'll leave a #comment saying what you did and why. The honest move isn't pretending you found the truth; it's showing your work so someone else can see where you stood.

What this course is really grading

This is why we don't grade you on clean code. Insight, knowledge, wisdom aren't outputs you can compute — they're what's left after you've been honest about every arrow above them. By your final reflection, the question won't be "did you get the right answer?" It will be "can you explain the choices you made along the way?"

One more thing about that bottom-right corner. The climb from knowledge to wisdom can fail — and the failure isn't ignorance, which more information fixes. It's something stubborner: being full of knowledge that never changes you. The Greeks had a word for it, and in a few weeks — when we ask what happens if you let an AI do your thinking for you — you'll learn it. For now, just notice that tools can help carry you across every other arrow on the diagram. The last one, you cross yourself.

The humanities aren't about solving the mess of being human. They're about understanding it — and now, with a new set of tools, understanding it at a scale you could never reach by hand.