A "Don't Repeat Yourself" Syllabus

"Every piece of knowledge must have a single, unambiguous, authoritative representation within a system."
— David Thomas and Andrew Hunt, The Pragmatic Programmer (2020, 30)

This essay is part of the Living Syllabus project, an open-source initiative for resilient course design. You can view the full source code on GitHub. Be sure to check out the previous posts in this series, Evil Quine and Seizing the Interface.

You detect a recurring point of friction. Students keep missing a crucial step in the midterm project, so you rewrite a line in the grading rubric. You save the master document. The new rule is a model of clarity. Then you realize the old rule is still hardcoded inside five different Canvas assignment descriptions. You try to update them all by hand. The course falls out of sync.

This failure isn't an accident. It happens by design.

In the previous installations of this series, we systematically dismantled the spatial constraints of digital pedagogy. In The Evil Quine, we confronted the struggle of production, rejecting the Canvas WYSIWYG editor to write clean, modular code. In Seizing the Interface, we confronted the struggle of consumption, pulling the syllabus out of the dead binary of the PDF and weaving it directly into the living HTML of the activity stream.

We fixed the geography of the course. Now we have to fix how it handles Time.

A well-designed syllabus will break if you treat it like a carved stone tablet. We must stop viewing the syllabus as a defensive contract we publish once on the first day of class. The moment you publish a course, the semester begins to tear it apart. A syllabus has to survive this reality. We must treat the document like a codebase that requires maintenance, versioning, and bug fixes. To make the course self-sustaining, we need a system that holds a single source of truth while generating all the documents the students actually see. We need to build a Don't Repeat Yourself (DRY) syllabus.

1. The Enemy of Time: Entropy and "Versioning Hell"

A static document begins to rot the second it encounters reality. The academic calendar attacks your initial plan. A winter storm cancels a Tuesday lecture. A global event forces you to change the weekly reading. Students struggle with a difficult concept, so you have to stretch a unit across two weeks. A static syllabus cannot swallow these changes. It just breaks.

The Learning Management System makes this worse by forcing you to copy and paste. It creates The WET Problem: Write Everything Twice. Your late policy lives in the PDF syllabus. To make sure students read it, you paste it into a Canvas assignment description. Later, you paste it again into a weekly announcement. This repetition guarantees failure. When you eventually update the rule in one place but forget the others, the course enters Versioning Hell. The professor loses track of the actual rule.

David Thomas and Andrew Hunt explain this decay using the Broken Window Theory (2020, Topic 3). In urban planning, a single unrepaired broken window signals abandonment. It invites further vandalism. In a codebase or a syllabus, leaving one contradictory due date unfixed signals that the document is no longer authoritative. Once students realize the schedule is unreliable, they stop trusting the entire course architecture. The system collapses because of a single ignored fracture.

When a student sees three conflicting due dates on three different Canvas tabs, they panic. This confusion isn't their fault; it is a failure of the professor's design. We have to recognize breakdown as our "epistemic and experiential reality" (Mattern 2018, Introduction). Expecting a teacher to manually update a dozen scattered documents every time the schedule changes is unsustainable. It punishes the teacher who has to manage the paperwork, and it punishes the student who has to navigate the wreckage.

We can understand this failure by looking at infrastructure. Lee Vinsel and Andrew L. Russell separate shiny innovation from the gritty work of maintenance (2020, Chapter 1). Digital pedagogy loves innovation-speak. Schools constantly buy new gamified apps, proprietary platforms, and ed-tech gadgets (2020, Chapter 2). Administrators chase Clayton Christensen's theory of "disruptive innovation," pushing endless technological novelty into the classroom. But as Vinsel and Russell argue, disruption is a consultant-driven mythology with no empirical basis in long-term survival. Chasing novelty ruins the actual foundation of the classroom. Teaching needs maintenance and care. We need a syllabus built for upkeep. Vinsel and Russell argue that "maintenance is the constant war against entropy... over time and without intervention, every system will decline into disorder and randomness" (2020, Chapter 3).

When we focus on maintenance, we align teaching with care work. We look to theorists like Mierle Laderman Ukeles, whose philosophy of maintenance art challenges the idea that only building new things matters. We have to ask: who picks up the digital garbage on Monday morning when the LMS breaks down? The teacher does.

We can measure this burden using the thermodynamic equations in Vinsel and Russell's analysis of entropy. Let $S(t)$ represent the total disorder in the course—the broken links and conflicting due dates—at time $t$.

$$S(t) = S_0 + \int_{0}^{t} \Delta E(t) ,dt - W_{m}$$

Here, $\Delta E(t)$ represents how fast the links and schedules degrade over time. $W_{m}$ is the sweat the professor puts in to keep the system running. In a WET syllabus, because you copied the rules into five different places, the baseline disorder is massive. You have to exponentially increase your labor ($W_{m}$) just to prevent the course from collapsing.

Shannon Mattern warns us about the cost of ignoring this upkeep. Putting off maintenance creates a "slow disaster" (Mattern 2018, Introduction). Mattern points out that maintaining codebases costs far more than building them in the first place. When an instructor brings the Silicon Valley "fail fast" mindset to a syllabus, they ensure the student experience will crash. Instead, we must use anticipatory repair (Mattern 2018). We have to build a course that expects to break, wiring survival directly into its bones.

2. The Architecture of Survival: The DRY Principle

To survive the semester, we have to rethink what a syllabus is. We need to think like programmers. Schools treat the syllabus like a legal contract to protect against lawsuits (Ludy et al. 2016, 2). Ludy et al. point out that this fear drives syllabus bloat, stuffing the document with endless policy clauses. This bloat turns a map for learning into a suffocating ledger. When the syllabus exists just to settle arguments, the work of maintaining the rules takes over the work of teaching.

We have to stop pretending a syllabus can predict every possible scenario (Cordell 2016). Instead, we should treat it like a codebase that gets versioned and fixed on the fly. We need to apply software engineering to course design. The core rule here is the DRY Principle: Don't Repeat Yourself.

Thomas and Hunt lay out the mandate: "Every piece of knowledge must have a single, unambiguous, authoritative representation within a system" (2020, Topic 9). We need a system where you write the grading rubric or the reading schedule once, in a plain text file. That file becomes the single source of truth. You update the rule in that one file, and a script automatically publishes the change out to every platform. You never sync documents by hand again.

They describe this separation using the geometric concept of Orthogonality (Thomas and Hunt 2020, Topic 10). In geometry, two vectors are orthogonal if they are independent, meaning a change in one does not project onto the other:

$$\vec{u}\cdot\vec{v}=0$$

In a syllabus, your course policies ($\vec{u}$) and your visual presentation on Canvas ($\vec{v}$) must be strictly orthogonal. You should be able to alter a grading policy without accidentally breaking the CSS layout of your learning management system.

To do this, we have to separate the text from how it looks on the screen. Dennis Tenen and Grant Wythoff argue that dressing up text inside programs like Microsoft Word is wasted labor (2014). Word processors inject messy, hidden code that breaks as software updates. Pulling from Charlie Stross's critique of word processors, they champion plain text. Plain text never breaks. It lasts forever. A resilient syllabus uses Markdown to tag what a piece of text is—like a header or a list—not what it looks like. By separating the words from the visuals, a teacher can redesign the entire look of the course without touching a single rule. Attempting to draft content and format visuals simultaneously destroys a writer's focus. Isolating generation from styling preserves your analytical momentum. You just write.

Turning a simple text file into a DRY syllabus takes a compiler. You write the rules in Markdown. A parsing engine like node-pandoc—a tool the authors call "humanities computing at its best"—reads the Markdown and translates the document into an Abstract Syntax Tree (AST), effectively understanding the meaning of the text rather than just its visual appearance. Then, a cross-platform Node.js batch builder (build.js) orchestrates the transformation. The system compiles the raw text into a variety of formats simultaneously, utilizing a --artifact=both flag to generate standalone PDFs alongside semantic HTML.

But generating HTML is not enough. The modern Learning Management System is a walled garden. Canvas employs an aggressive HTML sanitizer (canvas_sanitize) that strips out code it deems unstable. It aggressively deletes JavaScript (<script>), blocks external stylesheets (<link>), and strips internal style blocks (<style>). Attempting to paste a standard website into Canvas results in a broken, unstyled mess. Canvas forces you into its default aesthetic.

To bypass this restriction, the compiler acts as a chemical refinery. We use a CSS inliner package called juice combined with postcss. These tools take modern, classless CSS frameworks—like the Ivy League "Academic" serif theme, the fluid "Modern" sans-serif theme, or the high-contrast "Brutalist" theme—and chemically bond the design directly onto the HTML tags themselves as inline style="..." attributes. The engine flattens modern CSS variables into static values. Because Canvas ignores external classes but respects inline styles, the resulting HTML snippet is entirely "Canvas-Safe." You paste the generated code directly into the Canvas Rich Text Editor. The design survives the sanitizer intact.

We verify this survival through a literal Litmus Test. Before deploying a new component, we paste a highly specific HTML block into Canvas—a test featuring a native <details> accordion tag and a display: flex; flex-wrap: wrap; container. If the Canvas instance strips the flex-wrap, we know the system rejects modern responsive layouts, and we must fall back to basic block rendering. When the Litmus Test passes, we prove that we can successfully tunnel a modern, "Fluid Hybrid" layout through the LMS firewall.

[Authoritative Source]     [The Compiler/Generator]          [Deployment]
+-------------------+     +------------------------+     +-----------------+
| Markdown Document |     | node-pandoc (Parsing)  |     | Canvas LMS      |
| (Modular Policies)| ==> | juice + postcss        | ==> | Activity Stream |
| (Single Truth)    |     | (Inline Style Bonding) |     | (Canvas-Safe)   |
+-------------------+     +------------------------+     +-----------------+

This setup makes the course easier for students to use. The UMass Amherst Center for Teaching & Learning states that courses must be modular and semantically clean to be accessible. Because the text is completely separated from the visuals, the compiler instantly generates alternative formats, breaking down barriers for students. We utilize minimal computing protocols, ensuring that all images receive descriptive alt text and that high-contrast borders provide tactile depth without relying on heavy graphic assets. The clean HTML generated from the Markdown works perfectly with screen readers, exposing the hidden curriculum by making the course structure obvious.

Ludy et al. proved this works in the classroom. They tested a dense, legalistic syllabus against an engaging, visually distinct syllabus based on Linda B. Nilson's designs (Ludy et al. 2016). They found that a clean layout reduces fatigue and makes students less anxious about the rules. A DRY syllabus does this automatically. By utilizing classless CSS swapping, you manage the raw text, and the compiler applies the clean visual layout, structurally insulating the syllabus from the restrictive global styles of the LMS.

Finally, a DRY syllabus protects the history of the course against institutional erasure. Abby Smith Rumsey notes that our era of Information Inflation produces a paradox (2016, Chapter 1). We have massive amounts of data, yet the digital memory of a course is incredibly fragile. Rumsey shows that keeping digital networks alive requires massive human labor. When the semester ends, the university wipes the Canvas server. The history of the course vanishes.

To save the record, we treat the syllabus as a versioned codebase. We employ Continuous Integration tools like GitHub Actions (build.yml). Every time a professor pushes an update to the source Markdown, the automated pipeline spins up, builds the dist/ directory, and injects cryptographic hashes, author metadata, and timestamps directly into the generated HTML. We prove the syllabus is a versioned codebase. We acknowledge Ken Thompson's classic warning about "Trusting Trust"—we are pasting code into a Canvas system we do not control (Thompson 1984). Therefore, the injected cryptographic metadata ensures the syllabus functions as a durable, auditable artifact, surviving long after the server is wiped clean.

3. The Pedagogy of Modularity

We also have to look at what this broken architecture does to a student's brain. Moving from a messy, hand-updated syllabus to an automated system isn't just about saving the teacher time. It is a pedagogical necessity. By removing the friction of the LMS, we free up the student's ability to think. We do this through modularity.

We can understand how this works by looking at the philosopher Gilbert Simondon's taxonomy of machines. Simondon argues that a primitive machine is an abstract technical object: a clunky pile of isolated parts (2017, 26-27). Abstract systems use too much material and break easily. If one small gear stops, the whole machine dies. Because the parts remain separate, the abstract object "is logically simpler, yet technically more complicated, because it is made up of a convergence of several complete systems" (Simondon 2017, 29).

The traditional syllabus is an abstract machine. It is a disjointed mess: a PDF file over here, a Canvas module over there, three emails in an inbox, and a grading rubric on a separate website. Because the pieces never actually talk to each other, a single schedule change forces the teacher to run around manually fixing every isolated part. This structure suffers from what Simondon calls hypertely—a state of rigid, functional over-adaptation (2017, 61-62). A hypertelic object is so specialized to one exact scenario that it becomes useless the second the environment shifts. When a legalistic syllabus maps out every possible contingency for week three, it becomes a hypertelic dead-end. A snow day renders the entire hyper-specific document obsolete.

Simondon says machines only survive by evolving into concrete technical objects. In a concrete system, the parts collapse together until one structural piece handles multiple jobs at once (2017, 39). Simondon warns that bolting on "made-to-measure" customizations from the outside only encumbers the machine with dead weight. To fix the machine, you have to converge the functions "into a structural unit, rather than... seeking a compromise between conflicting requirements" (2017, 28).

We can map this to the classroom. Imagine an abstract syllabus $O_{abs}$ made of disconnected pieces: the PDF schedule $S_1$ and the Canvas tab $S_2$. Because they share no connection ($f(S_1) \cap f(S_2) = \emptyset$), the teacher has to edit both files when a snow day hits. This risks desynchronization. The DRY syllabus builds a concrete object $O_{con}$. A single Markdown file $S_{new}$ powers both the printed document and the Canvas site at the same time: $f(S_{new}) = f(S_1) \cup f(S_2)$. By turning the syllabus into a concrete machine, we kill the instability. As Simondon writes, the concrete object "is one that is no longer in conflict with itself, one in which no side-effect is detrimental to the functioning of the ensemble" (2017, 39).

This directly impacts how students learn. John Sweller's Cognitive Load Theory maps out how working memory handles instructional design (1994, 296). Sweller divides the difficulty of a class into two buckets: the actual difficulty of the subject matter, and the artificial difficulty caused by bad formatting. He defines Extraneous Cognitive Load as the mental processing wasted on bad design, like redundant text or scattered information (Sweller 1994, 303).

When a syllabus splinters into five different versions, it dumps extraneous cognitive load onto the student. A student reads a late policy in a PDF, but sees a different due date on Canvas. To figure out what the professor actually wants, the student has to hold both conflicting facts in their working memory and try to fuse them together. Sweller calls this the Split-Attention Effect (1994, 302). He observes that "the cognitive effort required to mentally integrate disparate sources of information can be reduced or eliminated by physically integrating the various entities."

Rumsey explains the biological stakes of this overload. She points out that the brain's survival relies heavily on the Art of Forgetting—the ability to aggressively filter out useless noise to focus on what matters (Rumsey 2016, Chapter 7). She highlights the case of Luria's patient, S., a mnemonist whose brain lacked this filtering mechanism. Because S. could not prune redundant or conflicting data, he was paralyzed by distraction, drowning in a flood of unorganized sensory input. When we force students to hunt through five different syllabus addendums to find a due date, we trap them in this exact disorder of distraction.

Making students read the same redundant policy in three places wastes their energy. The student ends up doing unpaid maintenance labor just to figure out the rules of the course before they can even start learning the material. We can map this failure using a simple formula for cognitive capacity. The total cognitive load ($L_T$) a student can handle is the sum of three variables:

$$L_T = L_I + L_E + L_G$$

Intrinsic Load ($L_I$) is the actual difficulty of the subject matter. Extraneous Load ($L_E$) is the wasted energy caused by bad formatting and versioning hell. Germane Load ($L_G$) is the productive effort the brain uses to actually learn the material. A student's $L_T$ has a hard, biological limit. If a fragmented, WET syllabus pushes Extraneous Load ($L_E$) to the maximum, Germane Load ($L_G$) drops to zero. The student literally has no brainpower left to learn.

Logistical chaos makes students anxious. It forces them to fight the interface instead of studying the content. When the course architecture is clean—when the DRY compiler ensures there are no conflicting due dates—this wasted mental load drops to zero. The student can focus entirely on the subject.

Sweller models this overload through Element Interactivity (Sweller 1994, 304). High-element interactivity happens when a student has to process multiple moving parts at the same time. Sweller uses formal algebraic notation to prove this mechanical reality. To isolate a variable in the equation $\frac{a}{b} = c$, a student cannot learn the steps in sequential isolation. They must multiply both sides by $b$, yielding $\left(\frac{a}{b}\right)b = cb$, resulting in the cancellation $\frac{ab}{b} = cb$, to finally arrive at $a = cb$. Sweller proves these steps are multiple interacting elements that the brain has to hold all at once (1994, 306-307).

If the academic subject is already difficult, injecting artificial difficulty into the syllabus guarantees the student will crash. The DRY syllabus solves this by grouping the logistics into a clean package. Sweller notes that a schema "organizes the elements of information according to the manner with which they will be dealt" (1994, 295). This architecture allows the student's brain to bypass memory limits by treating the entire syllabus as a single, reliable chunk.

We have to distinguish this from the popular trend of the Liquid Syllabus. The liquid syllabus movement correctly identifies that formal, legalistic documents scare students. But it responds by slapping a cheery, mobile-friendly CSS skin over the rot. It tries to build a friendly brochure. Applying a fresh coat of paint to a broken system does not fix the temporal problem. Simondon warns against this, noting that "the made-to-measure aspect... goes against the essence of the technical being, it is like a dead weight imposed from the outside" (2017, 28).

The DRY syllabus doesn't coddle the student with cheerful graphics. It builds a system strong enough to let the professor pivot. A concrete infrastructure provides the stability needed for a "Pedagogy of Discomfort"—pushing students into difficult academic terrain without the course itself collapsing. Simondon reminds us that a truly advanced machine is an "open machine" possessing a "margin of indeterminacy," empowering it to receive outside information and adapt (2017, 17). By acting as the organizers of these open machines, educators make sure the syllabus survives the semester, shielding students from the chaos and letting the learning begin.

References

Center for Teaching & Learning. How Do I Write an Inclusive Syllabus? University of Massachusetts Amherst.

Cordell, Ryan. "How Not to Teach Digital Humanities." Debates in the Digital Humanities 2016, edited by Matthew K. Gold and Lauren F. Klein, University of Minnesota Press, 2016.

Ludy, Mary-Jon, et al. "Student Impressions of Syllabus Design: Engaging Versus Contractual Syllabus." International Journal for the Scholarship of Teaching and Learning, vol. 10, no. 2, July 2016, Article 6.

Mattern, Shannon. "Maintenance and Care." Places Journal, November 2018.

Rumsey, Abby Smith. When We Are No More: How Digital Memory Is Shaping Our Future. Bloomsbury Press, 2016.

Simondon, Gilbert. On the Mode of Existence of Technical Objects. Translated by Cécile Malaspina and John Rogove, Univocal Publishing, 2017.

Sweller, John. "Cognitive Load Theory, Learning Difficulty, and Instructional Design." Learning and Instruction, vol. 4, 1994, pp. 293-312.

Tenen, Dennis, and Grant Wythoff. "Sustainable Authorship in Plain Text using Pandoc and Markdown." Programming Historian, 19 Mar. 2014.

Thomas, David, and Andrew Hunt. The Pragmatic Programmer: Your Journey to Mastery, 20th Anniversary Edition. Pearson Education, Inc., 2020.

Thompson, Ken. "Reflections on Trusting Trust." Communications of the ACM, vol. 27, no. 8, Aug. 1984, pp. 761-763.

Vinsel, Lee, and Andrew L. Russell. The Innovation Delusion: How Our Obsession with the New Has Disrupted the Work That Matters Most. Penguin Random House, 2020.