There is a strong link between critical theory and critical pedagogy. Critical pedagogy is a philosophy of education and social movement that developed and applied concepts from critical theory and related traditions to the field of education and the study of culture. It examines educational processes and institutions within the context of societal power structures, inequalities, and ideologies. Its goal is to recognize, analyze, and combat existing social injustices by using education as a tool for liberation and empowerment of individuals and communities. As critical pedagogy questions traditional educational practices and structures, it aims to develop alternative educational models that promote social justice, democracy, and emancipation. It emphasizes the importance of empowerment, participation, and critical consciousness among learners and educators.

The connection between critical pedagogy and CCS can be rooted in their shared emphasis on questioning power structures, promoting critical consciousness, and fostering social change within educational and technological contexts. Recent works such as Teaching Machines by Audrey Watters or Tracking technology: exploring student experiences of school datafication by Luci Pangrazio, Neil Selwyn, and Bronwyn Cumbo, for example, signal an upcoming wave of critical positions against educational technologies and their implications for education. I believe CCS can contribute here with methodological considerations and case studies such as code critiques, dashboard analysis, concept analysis of adaptive learning environments, or the debunking of myths surrounding AI in education.

Quite a few questions come to mind, when trying to link educational technologies, philosophy of education and CSS:

• How do educational technologies shape teaching and learning practices?
• What are the ethical implications of educational technologies?
• What alternative visions of educational technology are possible?

More informative and general:

Are there already approaches for using CCS as a framework for critically examining the social, cultural, and political dimensions of educational technologies and envisioning more equitable and empowering educational futures?

Copied from a comment by Mark Marino, useful teaching sources include:

• Critical Code Studies, Marino
• Aesthetic Programming, Cox and Soon
• 10 PRINT CHR$(205.5+RND(1)); : GOTO 10, Montfort et al.
• Travesty Generator, Bertram
• Poetic Operations, Cardenas
• Race After Technology, Benamin
• If Hemingway Wrote JavaScript, Kroll
• #!, Montfort

We have also seen many people reporting using programming languages including:

• Python
• JavaScript
• P5 (JavaScript)

Every institution is different, and curriculum is always an ongoing conversation. However, a strong theme of many comments on their teaching experiences seem to fall into three general categories:

CCS as:

• Paired with sister field (digital media, computational creativity, visual design, etc.)
• Modules within a larger structure (a single week or multiple weeks on the topic of critical code studies)
• Dedicated courses (i.e. Jeremy's and Mark's notes on teaching courses).

I'd like to try to promote discussion around an important question raised by these responses: are we ready for an advanced course on Critical Code Studies? What I mean by this question is trying to work through what objectives can be mapped to these different needs and then attempting to plan how an introductory course might be different from an advanced course on the same topic. If a two-course structure could be planned, what topics would come first, and which others could be used in the follow-up course?

Many years ago, I worked as part of faculty engagement. One of the best tools we used to help people understand the curriculum of their programs and departments was to create personas of the type of students they had within the program and then figure out what skills these personas would develop across sequences of courses or within a single course. Applying those processes to CCS and what comments I have seen this year, I'd like to propose some limited personas:

• Undergraduate students with some digital literacy skills. In taking an introduction course with CCS content, these students would be shown introductory programming concepts, how to potentially read code they might encounter, and how to describe, at least in part, how concepts in code produce different potential outcomes or cultural effects.

• Graduate students with mixed digital literacy and programming knowledge. For these students, the goal would be to demonstrate how cultural theories and frameworks can be paired with code analysis. Through engaging with critical code studies, these students would be better prepared to critically engage with existing tools, code libraries, and application workflows within their own work and potentially how to better help their own students.

Based on these limited personas, what might an advanced CCS course teach? Would a potential "second" course include greater programming knowledge, critical frameworks, research methods, or a mix of all three? What's the next step for us? Along with a discussion of existing courses, what might multiple modules or courses teach students? Within a longer sequence of courses, what might students learn?

Courses in Critical Code Studies (CCS) range from code classes with critical theory mixed in, to literary classes with code mixed in, to, more recently, classes where CCS is taught from start-to-finish, not to mention CCS “in the wild” where code critiques find their way into the hands of many inside and outside of teaching environments. With such a breadth of activity, certain growing pains can emerge, which is why we’re fortunate to have Mark Marino’s book, Critical Code Studies, to act as a guide and, in some cases, a lesson plan. The book includes an introduction to the field and also the Critical Code Studies Manifesto, a further explanation of the relationship between code and culture. Beyond the book, there are numerous other texts that can help with teaching, from articles in the Digital Humanities Quarterly to other books such as 10 PRINT CHR$(205.5+RND(1)); : GOTO 10. All of these include the required CCS components: code and critical analysis.

On its own, code can be tricky to teach. Code doesn’t always print well onto a page, it is difficult to read code up on a projector screen, and code is often dependent on other code and libraries that make it difficult to work with some code snippets. With such challenges, and those were only to name a few, code can be difficult to present in a classroom. Other questions related to teaching code include: in what format is code assigned? How is code annotated and using what tools? How are group discussions led when students come together? And, can students see code run? Questions like these are common in any field, like CCS, but are rooted in pedagogy that for most of teaching history placed the written word on paper as the primary means of knowledge transfer. Now that code is not an abstract concept for many, teaching must now cope with the nuances of code and requisite pedagogical changes.

Critical analysis in the classroom seems like a given: teachers are constantly asking students to think critically. Though, CCS asks readers to think along the lines of Critical Theory and Cultural Studies, sets of knowledge with specific vernaculars. How do we expect a student to learn the nuances of code—such as programming languages, algorithms, and data structures–while at the same time learning critical approaches to knowledge? The two can seem incompatible until some initial CCS examples are offered up. Consider the Transborder Immigrant Tool, a program for turning cell phones into devices that find water in the desert that is featured prominently in Critical Code Studies. When code is amply annotated with comments that point towards an activist strategy, as it is with the Tool, it is easier to imagine how it could operate successfully for both critical analysis and code lessons. But what about code that isn’t constructed in such a way? How can the interest of students be maintained across literary, computer science, and other fields when the criticality of code is more opaque?

Whether CCS is sprinkled into a literary or computer science class, constructed from the ground up as a semester-long endeavor, or something in between, there are few public syllabus examples that can be called upon during the formation of a course. However, that can change in this working group thread. For example, here are the assigned books for a syllabus I am creating for a full-length CCS class:

• Paul du Gay, et al, Doing Cultural Studies: The Story of the Sony Walkman (First Edition). Thousand Oaks, CA: SAGE Publications (1997).
• Mark Marino, Critical Code Studies. Cambridge, MA: MIT Press (2020).
• Nick Montfort, et al, 10 PRINT CHR$(205.5+RND(1)); : GOTO 10, Cambridge, MA: MIT Press (2012).
• micha cárdenas, Poetic Operations: Trans of Color Art in Digital Media. Durham, NC: Duke University Press (2020)

The inclusion of Doing Cultural Studies points towards the need to introduce students, in the context of this course, to the generalities of Critical Theory. The next two books are likely to show up on many CCS syllabi, while the last, Poetic Operations, suggests that code for computer operations isn’t the only code that CCS can analyze. In this case, the books are purposefully targeted at both computer science and non-computer science students.

It may also be important for a syllabus to introduce Critical Code Studies as a field; is a knowledge of CCS assumed or should it be described at the onset of the course? While my personal taste is to let definitions develop organically as a course develops, my CCS syllabus includes an introduction by way of quoting Critical Code Studies and other texts. For example:

“To read and interpret code does not necessarily mean to discover secret content or to uncover its unconscious bias or even to reveal unusual functioning. Instead, to read code critically is to explore the significance of the specific symbolic structures of the code and their effects over time if and when they are executed (after being compiled, if necessary), within the cultural moment of their development and deployment.” (Marino 23)

Here it is put forth that CCS isn’t necessarily the search for “gotcha” code, something that might come as a surprise (or bummer) to students new to CCS. In fact, as Critical Code Studies points out, CCS can be used to disprove so-called Climategate code, a sort of “reverse gotcha”, so code critiques of this rhetorical form do exist. It is up to teachers to find a balance between code intertwined in activist concerns and code that does, say, everyday tasks. Or to put into CCS terms: it is up to teachers to convey that the meaning of code changes when placed in activist, reactionist, and functional contexts.

For this Working Group thread, I propose that we post syllabi for courses that may include or focus on CCS, and syllabus components such as individual assignments and descriptions. Submitted content need not be for courses actually taught, but can include prospective materials. Discussion can jump off from the questions posed above, or new questions can be posed. But let’s not forget important ancillary discussions, such as: the kind of CCS courses that are being approved at colleges and universities; CCS-adjacent methodologies; classroom environments that promote the reading of code; field trips to code/art shows; and, institutional support for CCS. Of course, code snippets and critiques can only benefit the conversation, so feel free to post away!

Discussion questions gleaned from the text above:

• Presentation:

1. In what format is code assigned?
2. How is code annotated and using what tools?
3. How are group discussions led when students come together?
4. And, can students see code run?

• Criticality:

1. How can students learn the nuances of code—such as programming languages, algorithms, and data structures–while at the same time learning critical approaches to knowledge?
2. How can the interest of students be maintained across literary and other fields when code is difficult to decipher?

• Pedagogy:

1. What kind of CCS courses are being approved at colleges and universities?
2. Are there CCS-adjacent methodologies?
3. What classroom environments promote the reading of code?
4. What about field trips to code/art shows?
5. Any institutional support for CCS?