Seizing the Interface

"Interfaces are not simply objects or boundary points. They are autonomous zones of activity."
— Alexander R. Galloway, The Interface Effect (2012, vii)

1. Message in a Bottle

It is the second week of the semester. You have already delivered the introductory lecture. You have explained the course mechanics. And yet, the notification badge on your inbox lights up with the inevitable question: "Professor, which version of the schedule is right? The one in the Syllabus tab, the one in the Modules, or the one you emailed us?"

This confusion is a structural inevitability of the Learning Management System. The LMS operates as what Chun terms an Empowering Obfuscation. It offers an illusion of transparency and direct manipulation—drag-and-drop modules, satisfying green "Publish" buttons—masking the fact that the system screens us from the underlying logic of the course (Chun 2011, 59). This obfuscation relies on a design philosophy where interface has been supplanted by experience. As Olia Lialina argues, the primary goal of this User Experience (UX) paradigm is "to hide the programmability or even customizability of the system" and "to minimize and channel users' interaction" (2021, 46). The interface creates a user who feels powerful only within the mousetrap of its constraints (Chun 2011, 66). By locking content into these daemonic interfaces—daemonic because they run hidden processes we cannot see or touch (Chun 2011, 60)—we force the student to accept an "illusion of unmediated natural space" (Lialina et al. 2021, 47) lacking fidelity to the territory of learning objectives.

This creates what Galloway calls an Intraface, a "zone of indecision" where the edge of the system battles the center of our content (2012, 40). The student is trapped in the friction between the navigation of the course (Modules, Calendar) and the navigation of the document (the PDF's internal dates). By maintaining two distinct regimes of navigation—one native to the web, one native to print—we force the student to arbitrate a conflict we failed to resolve. This unresolved friction creates the condition for what Lialina calls the Invisible User. As she warns, "The Invisible User is more of an issue than an Invisible Computer" (Lialina et al. 2021, 14). When we strip away the visible friction of the file system in favor of the smooth experience of the Module, we delete the reminder that "there is, whether visible or not, a computer, a programmed system you use" (Lialina et al. 2021, 13). We are left with a user who is technically present but structurally absent, navigating a system that denies their existence as anything other than a data point.

There is a phrase etched into the tombstone of every academic career, a mantra muttered in faculty lounges and vented on Twitter with increasing desperation: "It is in the syllabus."

We succumb to what Wendy Hui Kyong Chun calls Sourcery: the magical belief that the source code of our policies inevitably governs the execution of the course (Chun 2011, 19). We act as if the syllabus is a sovereign text where the command "Read this" acts as its own fulfillment. By conflating instruction with result, we ignore the "vicissitudes of execution" that actually define the semester (Chun 2011, 21). The syllabus becomes a fetish object, a way to manage our anxiety about the chaos of the classroom by pretending that writing the rule is the same as enforcing it.

Academics often default to the Deficit Hypothesis. We attribute the missing reading to moral failure, generational laziness, or the corrosive effects of TikTok. We treat the student as a naive user who must be protected from the complexity of the file directory. Yet this underestimates their potential. We should instead treat the student as what Lialina calls a General-Purpose User or a Turing Complete User—one who possesses "the ability to achieve their goals regardless of the primary purpose of an application" (2021, 23). The student does not lack the discipline to click "Files"; they lack a system that acknowledges their capacity to navigate General-Purpose Technology (Lialina et al. 2021, 22). By trapping them in a busy interface designed for passive consumption, we deny them the autonomy to "find a way to their aspiration".

I propose a different explanation: the Interface Hypothesis. We are attempting to solve a structural problem with moral indignation.

In the previous post, we examined the struggle of production—how the "Evil Compiler" of the Canvas editor mangles our attempt to write a clean document. Here, we confront the struggle of consumption. Students fail to read the syllabus because we have committed a category error in design.

We treat the syllabus as a paper native object, a linear narrative designed for the printing press. But we deploy it into a cloud native environment, a fluid database designed for the stream.

By persisting with the PDF, we have inadvertently turned the syllabus into what Matthew Fuller describes as a "standard object," akin to the ISO shipping container. Just as the shipping container was designed to circulate goods globally by rendering their specific contents immaterial to the mechanism of transport (Fuller 2005, 94), the LMS file repository is designed to circulate "content" while remaining aggressively indifferent to its pedagogical intent. The file becomes an "ideally isolated system" (Fuller 2005, 93), a sealed box that the system can sort, tag, and timestamp, but which the student cannot open without stepping out of the stream of the course. We have prioritized the logistics of the container over the accessibility of the cargo.

When we upload a PDF to a Learning Management System (LMS), we throw a message in a bottle into an ocean of data. We hope it washes up on the student's mental shore, but in reality, it drifts aimlessly in the "Files" repository, disconnected from the "Activity Stream" where the student actually lives. To the modern student, if information is not on the surface, it does not exist.

We face a choice. We can continue to lament that students don't read the files we hide from them, or we can accept a difficult truth: to teach effectively in the digital age, we must become Interface Designers.

To design an interface is not merely to arrange pixels; it is to fundamentally alter the "address" of the technology. We should look to the example of the artist Jakob Jakobsen, who installed a manual switch on a municipal streetlight, suddenly transforming a piece of infrastructure "addressed" to the central town planner into one addressed to the local resident (Fuller 2005, 92). The LMS, in its default state, is addressed to the registrar and the administrator; its "affordances" are tuned for compliance and archival auditing (Fuller 2005, 45). By breaking the PDF out of its container and weaving the syllabus directly into the web of the course, we act as Jakobsen did: we install a switch that redirects the address of the system away from the institution and back toward the student.

II. The Interface Effect

To understand why a student ignores a hidden syllabus, we must reject the assumption that a screen is a neutral pane of glass. Alexander Galloway challenges this intuition in The Interface Effect, arguing that we tend to view the interface as a transparent window allowing direct access to data. This is an ontological error; the interface is never a neutral medium. In fact, as Olia Lialina notes, the very definition of transparency has mutated in the shift to modern interfaces. It no longer means clarity of operation; it means "that [users] could immediately make it work, not that they knew how it works" (Lialina 2007, 9). By prioritizing this intuitive gloss, we build systems that are "not counting on users' competence and ability to see and understand" the very tools they depend on (Lialina 2007, 8).

We must stop thinking of the syllabus as a noun and start thinking of it as a verb. As Galloway notes, "interfaces are not things, but rather processes that effect a result of whatever kind" (2012, vii). When we upload a static PDF, we attempt to freeze this process into an object. We are trying to push a stone through a hose. The LMS, however, is an "autonomous zone of activity"that demands the syllabus behave like a current, not a sediment.

In the LMS, this process prioritizes the stream over the archive. The Canvas Dashboard, the student's primary reality, functions as a temporal interface organizing the world into urgent notifications. It suppresses the spatial interface of the filesystem where static documents reside.

This invisibility is the system's primary feature. It reflects a shift in power dynamics: Files imply agency; the Cloud implies submission.

Wendy Hui Kyong Chun helps us understand the temporal dimension of this shift in Updating to Remain the Same (2016). In the cloud era, permanence signals obsolescence. A PDF is a Monument—static and unmoving. The student lives in the Eternal Now of the feed, where value is defined by the update. By uploading a static file to a dynamic stream, we fight against the user's habitual rhythm. The document feels dead because it does not breathe.

The PDF commits a cardinal sin of digital ontology: it forces data to adopt a single, immutable shape before it even reaches the student’s eyes. But in the digital realm, "data have no necessary visual form" (Galloway 2012, 82). Data are the "givens"—the raw readings, the due dates, the policies—which should be free to adopt whatever shape the student's device requires. By locking these "givens" into the 8.5x11 prison of the PDF, we rob the data of its ability to "take shape" within the native stream of the course. We are prioritizing the aesthetic of the printer over the logic of the network.

Ultimately, the "Living Syllabus" is not just a design preference; it is a pedagogical ethic. If the computer is "an ethic" because "it instantiates a practice not a presence" (Galloway 2012, 22), then our syllabus must mirror that ethic. It must be a set of executable practices—links that open, dates that update, modules that unlock—rather than a "presence" meant to be admired from afar. We must stop designing for the archive and start designing for the action.

We can measure this estrangement with a "Click Audit" of the standard PDF syllabus:

1. Dashboard (The Surface)
2. Course Homepage (The Gate)
3. Files Tab (The Archive)
4. Course Folders (The Labyrinth)
5. Syllabus.pdf (The Object)

In the user experience economy, every click is a gate that filters out a percentage of users. By burying the syllabus five clicks deep, we place it in cold storage. To the student navigating the Dashboard, if a document does not exist on the surface layer, it does not exist at all.

III. The Invisible User

If the interface is a control mechanism, the student is its subject.

In Turing Complete User (2012), Olia Lialina argues that the history of modern computing is the history of hiding the file. The title references the user's capacity for general-purpose computing, a capacity eroded by software designed to obscure the machine's gears. We cannot blame the "Invisible User" for failing to navigate structures we have worked to conceal.

When we rely on a static PDF, we ask students to navigate a spatial hierarchy that the LMS spent millions in UX engineering to hide.

Lialina notes that the User Experience paradigm operates on a philosophy of infantilization. By polishing away the jagged edges of the system—the file, the folder, the directory path—designers have created an environment where "the user is not supposed to see the computer" (Lialina et al. 2021, 6). In the name of efficiency, we have concealed the architecture that organizes information. The LMS creates a vaporous environment where the user feels powerful because the messy reality of the machine—directories, file paths, and code—is hidden from view. The student is trained to interact with surface-level buttons like "Submit Assignment" or "Next Module" and is estranged from the deeper logic of the file structure. The result is a user technically proficient at consumption but functionally illiterate in navigation.

This concealment is not accidental; it is the hallmark of the Rich User Experience. As the Critical Engineering Manifesto warns, we must learn to "deconstruct and incite suspicion" of these seamless interfaces (Oliver, Savičić, and Vasiliev 2011). When the LMS smooths over the friction of file management with a sleek dashboard, it is not merely being helpful. It is obfuscating the inner workings of the course, treating the student’s dependence on the platform not as a vulnerability to be solved, but as a feature to be maintained. By accepting this slick surface, we inadvertently train students to fear the jagged edges of actual computing.

This produces the Interface Captive. We mistakenly label students digital natives, assuming they understand the machine's logic. But as Lialina points out, they were raised in walled gardens designed to hide the file hierarchy, leaving them "emancipated from the computer" but alienated from its control (2021, 7). They are not simply navigating a system; they are being shaped by it. We must recognize that "each work of engineering engineers its user, proportional to that user's dependency upon it" (Oliver, Savičić, and Vasiliev 2011). The LMS, by design, engineers a user who is passive, reactive, and incapable of folder logic. When we lament that students cannot find the syllabus, we are criticizing the very behavior the machine was engineered to produce.

Here lies the fundamental category error. The PDF is a Narrative format—linear, novelistic, and fixed. It belongs to the logic of the printed page. The LMS is a Database environment—modular, query-based, and fluid. We attempt to impose a 19th-century mode of reading onto a 21st-century mode of retrieval. The student, trained by the interface to seek the stream, cannot see the book we have hidden in the basement. We have succumbed to what Lialina identifies as the shift from the Home Page to the Profile. In the era of the Vernacular Web, users built their own structures; today, "Home pages no longer exist. Instead, there are other genres: accounts, profiles, journals" (Lialina et al. 2007, 3-4). The LMS is a Profile-machine. It invites us to upload content into pre-ordained slots ("Files," "Assignments"), reducing the professor to a data-entry clerk. By accepting the Profile, we abdicate the right to design the architecture of the course.

IV. The Exploit

Since the interface functions as control, we must seize it rather than trying to teach students to love the file. We must stop fighting user habits and start exploiting the system architecture. This requires adopting the stance of the Critical Engineer, recognizing that dependent technologies threaten our agency.

The Syllabus as Code approach is a pedagogical imperative. By moving our syllabus out of the dead binary of the PDF and into the living HTML of the interface, we perform what Matthew Fuller calls an Exploit: using the system's own rules to subvert its logic.

Fuller argues that in a media ecology, standard objects like the LMS define the boundaries of possibility, but also contain "materialist energies" we can redirect. By writing our syllabus in the LMS's native HTML, we move the document from the archive to the interface, effectively breaching the walled garden.

We are seizing the interface. We are taking the syllabus out of the bottle and writing it directly onto the water.

This pivot is driven by a mobile-first necessity. We must acknowledge that the majority of our students access the course via a smartphone app hostile to print-native formats. The PDF requires the user to "pinch-zoom," a gesture of friction signaling the document is foreign to the device. The HTML component, conversely, utilizes the "spongy grid" of Flexbox to reflow content dynamically. By engineering our syllabus to respond to the device, we adhere to the Critical Engineering tenet that we must "expose and deconstruct" the user experience rather than blindly accepting the constraints of the provided template.

Consider the accordion component (the <details> tag) as a prime example of this exploit. A traditional syllabus presents legal policies as a "Wall of Text" that intimidates the reader. By wrapping these sections in an interactive HTML accordion, we respect the "Scan, Don't Read" behavior of the modern web user. We are not hiding the information; we are architecting its retrieval. We transform the syllabus from a static lecture into a responsive tool.

V. From Content to Architecture

Adopting "Syllabus as Code" transforms the professor from a content provider into an interface designer.

We are building a system rather than a static document. In the cloud era, synchronization is the only thing that matters. This workflow allows for Continuous Integration / Continuous Deployment (CI/CD): we can inject dynamic links or modular components that update everywhere at once. A PDF is a dead artifact that lies the moment a date changes. A living syllabus breathes, aligning pedagogy with the cloud's temporal reality by shifting our focus from files to versions.

The Critical Engineering Manifesto reminds us that engineering composes a mode of governance. Written code ultimately "expands into social and psychological realms, regulating behaviour between people and the machines they interact with" (Oliver, Savičić, and Vasiliev 2011). Accepting the default Canvas template means accepting its governance—a governance that prioritizes administrative uniformity over pedagogical engagement. If we do not intervene, the code regulates the behavior for us, creating a distance between professor and student that no amount of office hours can bridge.

We refuse this clean template of the institution. As Lialina notes of Facebook, the clean aesthetic is a class signifier used to denote professionalism and security, yet "the use of light colors and small fonts can't hide the structural clumsiness" of the system (Lialina 2007, 15). We must expose this clumsiness rather than hiding behind it.

By injecting our own Callouts, Grids, and Alerts into the bland LMS editor, we perform an act of resistance known as shadow IT. It is virtually unknown in standard faculty guides because it bypasses the sanctioned clear formatting buttons and LTI plugins. By rejecting the rigid template, we build what Ivan Illich calls a convivial tool—technology that enhances individual autonomy—rather than submitting to the logic of the Teaching Machine designed for behavioral conditioning. We reclaim the screen for our own pedagogical ends.

If we reject the static PDF, we must be careful not to romanticize the "Living Syllabus" as a biological entity. In the digital realm, our documents are more accurately described as undead. As Chun reminds us, digital information does not simply exist; it constantly degenerates and must be obsessively "refreshed" and "regenerated" to remain visible (Chun 2011, 133). The digital syllabus is an "enduring ephemeral" that survives only through our constant intervention (Chun 2011, 172). It is in media res—always in the middle of things, always dependent on the labor of upkeep to prevent it from disappearing into the "vapor" of the cloud (Chun 2011, 177).

This leaves one final technical challenge. If the syllabus is now a complex piece of software, how do we maintain it? How do we prevent this "living interface" from becoming a burden when the semester dates change? In the next post, "The Maintenance / DRY Syllabus," we will explore how to apply the software engineering principle of "Don't Repeat Yourself" to automate the labor of the living syllabus.

You can explore the live examples and documentation at the Living Syllabus Hub, or dive directly into the code and tools at the GitHub Repository.

References

Chun, Wendy Hui Kyong. 2011. Programmed Visions: Software and Memory. Cambridge, MA: The MIT Press.

Fuller, Matthew. 2005. Media Ecologies: Materialist Energies in Art and Technoculture. Cambridge, MA: The MIT Press.

Galloway, Alexander R. 2012. The Interface Effect. Cambridge, UK: Polity Press.

Lialina, Olia. 2007. "Vernacular Web 2". In Vernacular Web 2, 1–16.

Lialina, Olia. [2012] 2021. Turing Complete User: Resisting Alienation in Human Computer Interaction. Edited by Florian Hadler and Daniel Irrgang. Heidelberg: arthistoricum.net.

Oliver, Julian, Gordan Savičić, and Danja Vasiliev. 2011. The Critical Engineering Manifesto. Berlin: The Critical Engineering Working Group.