Howdy, Stranger!

It looks like you're new here. If you want to get involved, click one of these buttons!

Participants: Derya Akbaba * Ben Allen * Natalia-Rozalia Avlona * Kirill Azernyi * Erin Kathleen Bahl * Natasha Bajc * Lucas Bang * Tully Barnett * Ivette Bayo * Eamonn Bell * John Bell * kiki benzon * Liat Berdugo * Kathi Berens * David Berry * Jeffrey Binder * Philip Borenstein * Gregory Bringman * Sophia Brueckner * Iris Bull * Zara Burton * Evan Buswell * Ashleigh Cassemere-Stanfield * Brooke Cheng* Alm Chung * Jordan Clapper * Lia Coleman * Imani Cooper * David Cuartielles * Edward de Jong * Pierre Depaz * James Dobson * Quinn Dombrowski * Amanda Du Preez * Tristan Espinoza * Emily Esten * Meredith Finkelstein * Caitlin Fisher * Luke Fischbeck * Leonardo Flores * Laura Foster * Federica Frabetti * Jorge Franco * Dargan Frierson * Arianna Gass * Marshall Gillson * Jan Grant * Rosi Grillmair * Ben Grosser * E.L. (Eloisa) Guerrero * Yan Guo * Saksham Gupta * Juan Gutierrez * Gottfried Haider * Nabil Hassein * Chengbo He * Brian Heim * Alexis Herrera * Paul Hertz * shawné michaelain holloway * Stefka Hristova * Simon Hutchinson * Mai Ibrahim * Bryce Jackson * Matt James * Joey Jones * Masood Kamandy * Steve Klabnik * Goda Klumbyte * Rebecca Koeser * achim koh * Julia Kott * James Larkby-Lahet * Milton Laufer * Ryan Leach * Clarissa Lee * Zizi Li * Lilian Liang * Keara Lightning * Chris Lindgren * Xiao Liu * Paloma Lopez * Tina Lumbis * Ana Malagon * Allie Martin * Angelica Martinez * Alex McLean * Chandler McWilliams * Sedaghat Payam Mehdy * Chelsea Miya * Uttamasha Monjoree * Nick Montfort * Stephanie Morillo * Ronald Morrison * Anna Nacher * Maxwell Neely-Cohen * Gutierrez Nicholaus * David Nunez * Jooyoung Oh * Mace Ojala * Alexi Orchard * Steven Oscherwitz * Bomani Oseni McClendon * Kirsten Ostherr * Julia Polyck-O'Neill * Andrew Plotkin * Preeti Raghunath * Nupoor Ranade * Neha Ravella * Amit Ray * David Rieder * Omar Rizwan * Barry Rountree * Jamal Russell * Andy Rutkowski * samara sallam * Mark Sample * Zehra Sayed * Kalila Shapiro * Renee Shelby * Po-Jen Shih * Nick Silcox * Patricia Silva * Lyle Skains * Winnie Soon * Claire Stanford * Samara Hayley Steele * Morillo Stephanie * Brasanac Tea * Denise Thwaites * Yiyu Tian * Lesia Tkacz * Fereshteh Toosi * Alejandra Trejo Rodriguez * Álvaro Triana * Job van der Zwan * Frances Van Scoy * Dan Verständig * Roshan Vid * Yohanna Waliya * Sam Walkow * Kuan Wang * Laurie Waxman * Jacque Wernimont * Jessica Westbrook * Zach Whalen * Shelby Wilson * Avery J. Wiscomb * Grant Wythoff * Cy X * Hamed Yaghoobian * Katherine Ye * Jia Yu * Nikoleta Zampaki * Bret Zawilski * Jared Zeiders * Kevin Zhang * Jessica Zhou * Shuxuan Zhou

Guests: Kayla Adams * Sophia Beall * Daisy Bell * Hope Carpenter * Dimitrios Chavouzis * Esha Chekuri * Tucker Craig * Alec Fisher * Abigail Floyd * Thomas Forman * Emily Fuesler * Luke Greenwood * Jose Guaraco * Angelina Gurrola * Chandler Guzman * Max Li * Dede Louis * Caroline Macaulay * Natasha Mandi * Joseph Masters * Madeleine Page * Mahira Raihan * Emily Redler * Samuel Slattery * Lucy Smith * Tim Smith * Danielle Takahashi * Jarman Taylor * Alto Tutar * Savanna Vest * Ariana Wasret * Kristin Wong * Helen Yang * Katherine Yang * Renee Ye * Kris Yuan * Mei Zhang
Coordinated by Mark Marino (USC), Jeremy Douglass (UCSB), and Zach Mann (USC). Sponsored by the Humanities and Critical Code Studies Lab (USC), and the Digital Arts and Humanities Commons (UCSB).

Week 1: Introduction to Critical Code Studies (Main thread)

Jeremy Douglass and Mark C. Marino


Welcome to the first week of the 2020 Critical Code Studies Working Group. During this week, we’ll be introducing critical code studies in general by means of the introductory chapter to the forthcoming book Critical Code Studies (The MIT Press). We’ll also take this week as an opportunity to introduce newcomers to the field but also to take stock in where the field has come and to look forward to where it is headed next.

Critical code studies names the applications of hermeneutics to the interpretation of the extrafunctional significance of computer computer source code…. Extra here means not outside of or in addition to but instead growing out of…. CCS holds that the lines of code of a program are not value-neutral and can be analyzed using the theoretical approaches applied to other semiotic systems, in addition to particular interpretive methods developed specifically for the discussions of programs.

But what does it mean to explore culture through code?

Mark answers this question in the book, reading code as varied as the leaked software from the Climategate scandal to code written by media philosopher Friedrich Kittler. He reads art objects like the Transborder Immigrant Tool, variants of electronic literature works like Taroko Gorge, and code languages like the English-like precursor to COBOL, FLOW-MATIC. He explores low level to high level languages, from ASSEMBLY to Inform 7, including languages in Arabic (قلب or ’alb), Hawiian (in the ʻAnuʻu project), and Cree. (For much more on Indigenous Programming, look forward to our Week 2 discussion). In a medium most consider to be merely an operationalized mathematics, readings of code lead him to discuss issues of racial and ethnic bias and the gendered bias he calls encoded chauvinism. These readings have grown out of and reference discussions from past Critical Code Studies Working Groups because these collectives, these gathering of such varied minds, have the ability to identify so many complex meanings.

In the epilogue to the CCS book, Mark claims we have reached a moment where “philosophers process, poets publish, and curators collect code knowing scholars will interpret it as discourse” (227) -- in other words, where the basic tenets of critical code studies, that code is meaningful, have been widely accepted. How does that acceptance change the culture of code? How does that facilitate what we are trying to do here?

Because code has become accepted as a means of expression, we now have new works choosing code as one of their communication channels. Consider: Eugenio Tisselli's “Amazon” webpage, released over Twitter. Created in response to this summer’s devastating fires, Tisselli’s code articulated his despair over the environmental effects of globalized capitalism. Code was able to serve as his language of expression because, as, Alex McCLean and Geoff Cox have written, Code Speaks.

see related discussion: amazon.html by Euguenio Tisselli

Code is a social medium and its meaning is also social. The “critical” aspect of critical code studies looks to explore, among other aspects, this social dimension, especially as it pertains to power relations, across differences of race, gender, sexuality, and socio-economic status or class. “Critical” code studies is not technological history at the service of digital industries, it is an exploration of human culture in code complete with biases, abuses, inconsistencies, and injustices. CCS is an alternative to “uncritically documenting military-industrial-academic artifacts on behalf of those who created them to the benefit of their creators’ self-regard” (238). We aspire to more.

At the same time, it is worthwhile to look to critical theories and philosophical paradigms that you have found useful or would like to apply but perhaps can’t see how. Or maybe you have come across some code that you can’t read or can’t find a critical hand hold on. (This is a good time to introduce some of your code critique threads).

Programming has continued to evolve. New and strange languages have emerged. With the advent of contemporary machine learning algorithms, more code is being generated by software, code that programmers may never deal with directly. How does meaning change in such contexts? As more people discuss algorithms, what can the study of code add to those conversations?

So we invite the CCS community to begin this week of the Working Group with a broad, reflexive conversation, a thread that invites you to look back and forward, that invites you to express your thoughts about the potential obstacles for critical code studies as well as your own insights and inspirations.



Some questions:

  • What do you want to know about CCS?
  • What are the next challenges for Critical Code Studies? Current puzzles?
  • What projects would we like to launch in the coming years? An edited collection? Conference?
  • How has CCS been most productive?
  • What are some current questions or problems that CCS is uniquely suited to addressing?
  • What are the lacuna or blindspots--what should should CCS be addressing that it is not currently?


Comments

  • Here we come. This will answer my question to Mark Marino. What are the limits of CCS?

  • edited January 21

    That's a good question. Critical Code Studies names methods not an an area of knowledge, so it isn't limited in the way an area of knowledge would be. The limitations then come not so much from the methods as the application.

    To tell a brief story. When @nickm posted 10 PRINT during the first CCSWG, I remember thinking, could this be the limit? Here was a one-line program with no variables and no comments and only one word (PRINT) that looked like natural language. It was basically a simple (pseudo)randomized loop. What could we possibly say?

    But then the discussion unfolded. And then a group of 10 of us explored it in a book.

    Every CCSWG, every article, every new book proves how much more CCS can do. The limitation is only in the creativity and imagination of those who are applying it. That said, if you are hitting what feel like limits, raise them here. Maybe someone can help find a way beyond them.

  • My introduction to CCS came via reading Mark's essay "Reading Culture Through Code" a few months back. I shared it widely on Twitter, wanting other technologists (fellow practitioners primarily) to read it and discuss. There are frequent discussions on social media about the "human" side of tech, but I've not had any that explored code with the level of nuance CCS provides.

    I'd really like to understand how to bring the knowledge amassed in CCS back to practitioners. Those of us not in academic circles, but who create, edit, revise and otherwise interact with code every day, would find great value in analyzing our work through this particular lens. What role can CCS play in the lives of working professionals? How can it be applied to our everyday work? What frameworks exist (or need to be built) for this to happen?

  • What role can CCS play in the lives of working professionals? How can it be applied to our everyday work? What frameworks exist (or need to be built) for this to happen?

    These are excellent questions that I'd like to invite our professional programmers to answer.

    I think to answer this question, it might be useful to begin with a full sense of what CCS is and what it can offer. It is easy to see the way CCS can lead to a greater reflection on the ethical issues involved in programming. However, CCS sees and sets the cultural stakes of programming as a medium for both communication and operation, treating code like a meaningful, social and mechanical construction.

    Perhaps it is my humanities training that sees the key to fostering those insights in fostering discussion within diverse communities. I've become a lifetime fan of the seminar -- that realm where people gather to share at times widely varied reflections on a shared object. Hearing that wide array of perspectives, exploring from different angeles, applying different lenses -- maybe ones not usually applied -- asking those questions pertaining to social realms (race/ethnicity, colonialism, feminism) do new insights arise.

    So my suspicion is that discussion forums and conferences will be places to foster CCS among programing professionals. What if there were a StackExchange about meaning? A Slashdot aimed at culture? A LambdatheUltimate aimed at ethics? I believe there are already threads on these topics in these forums, but I guess I am advocating for discussions and discussion boards aimed less at how to make something and more into what it means when we make something in a particular way.

    But please, programmers, weigh in.

  • edited January 23

    I'm a newcomer to the field. How technically (in terms of computer languages etc) sound does one have to be to read code? I'm a critical media policy studies person. As I look to engage with policy documents further and also engage with people as I'm a policy ethnographer, I'm more interested in coding communities and their engagement with writing or editing or enacting code.

  • Years ago, @jeremydouglass taught me a valuable lesson: code is not magic; it is just a symbolic system. And people who read through a program all have to do it the same way, moving through sections and tokens piece by piece, looking up ones they don't understand. Reading someone else's code is often a daunting and undesirable task even to the most experienced. It is like finding your way through someone's kitchen, except the room might not turn out to be a kitchen at all. Or maybe they wired the fridge through the toaster. You too can read it with patience, like trying to translate a text from a language you are learning. But you will only be able to see so much.

    That is why I recommend reading code with others, especially someone more fluent in the language. They can act like a guide, like an emissary, a sherpa. They can understand the code more fully and typically more quickly. (And if you can read with the programmer who wrote the code, the experience is incomparable. Together you will find your way to and through your insights. But never forget that your critical insights give you a way into the code that no mere technical literacy, if that is the word, can efface. Your insights may be invisible to your companion as you move through the code due to their familiarity. So your lack of familiarity can be a major asset for interpretation.

    To read code, we need to know what it does but also how those familiar with its form, its genre, its milieu perceive it.

    And they can show you tools, like syntax highlighting editors and IDEs, that make the reading much easier.

    So I encourage you to explore code, but try travelling as I do with the humility of an outsider, a guest, finding a companion or companions who can read and teach you how to read the signs.

    I also recommend taking a programming course, if you haven't. The more you know, the better equipped you'll be to recognize meaning.

  • edited January 23

    @smorillo

    Those of us not in academic circles, but who create, edit, revise and otherwise interact with code every day, would find great value in analyzing our work through this particular lens. What role can CCS play in the lives of working professionals? How can it be applied to our everyday work?

    @markcmarino

    But please, programmers, weigh in.

    Putting on my programmer hat....

    I'm going to answer this by referencing three works that are, in one dimension or another, adjacent to CCS: Sherry Turkle's Simulation and Its Discontents, Peter Salus' A Quarter Century of Unix and Bruce Schneier's Applied Cryptography.

    Each of these passages changed how I think about my profession.

    Nuclear weapons design is divided by dramatic generational markers: some designers grew up with routine underground testing, some glimpsed it, some have only experienced virtual explosions. Some designers were trained to program their own simulations, some simply "grab code" from other people are are unfazed by the opaque. Yet when Luft sums up attitudes towards simulation in his field, he makes it clear that the wide range of opinion does not reduce to simple generational criteria. The cultures of weapons laboratories are also in play. For example, at Livermore, older weapons scientists who were very hostile to simulation became far more positive when the laboratory adopted a new metaphor for weapons design. Livermore began to liken weapons design to bridge building. According to this way of thinking, engineers do not need to "test" a bridge before building it: one is confident in its design algorithms and how they can be represented in the virtual. (Turkle, p74-5)

    I think what Bob Morris was telling me is that the black box itself should be simple enough such that when you form the model of what's going on in the black box, that's in fact what is going on in the black box. You shouldn't write a program to try and outwit the person and to try to double guess what they're going to do. You should make it such that it's clear what it it does. (Salus, quoting Joe Condon, p 38-9)

    There are two kinds of cryptography in this world: cryptography that will stop your kid sister from reading your files, and cryptography that will stop major governments from reading your files. This book is about the latter. If I take a letter, lock it in a safe, hide the safe somewhere in New York, then tell you to read the letter, that's not security. That's obscurity. On the other hand, if I take a letter and lock it in a safe, and then give you the safe along with the design specifications of the safe and a hundred identical safes with their combinations so that you and the world's best safecrackers can study the locking mechanism---and you still can't open the safe---that's security. (Schneier, xix)

    Each of those books fundamentally reoriented how I think about what I do. I don't know that any of them influence how I handle day-to-day chores (anyone out there have experience with getting the E3SM climate code running on Ubuntu?), but on days when I'm peer-reviewing or making design decisions or writing grant proposals, my thinking is shaped by those books (and many others). They had that influence because of the outsized importance of the topics they took on: Turkle (in this chapter) with nuclear weapons, Salus with the Unix ecosystem, Schneier with cryptography.

    CCS has the potential to have a similar level of impact, but to get there it needs to speak more to codes that programmers work with (and codes that affect programmers). At the top of my personal wish list is a CCS treatment of climate simulations, but that's just me. I do think it's easier to make an impact studying codes that have a useful life of decades; one exception is the loving description of BeOS in "In the beginning was the command line" (which could have also made the list above).

    Which bring me to the question @preetiraghunath raised: Do you have to be able to understand the code in (say) a climate simulation in order to do a CCS analysis of it? Turkle and Salus didn't make their reputation on their coding chops; both are world-class interviewers. There's plenty of work to be done, particularly by people who are trained in ethnography, in talking to programmers (and project managers, and stakeholders, and funding agencies) about their views of the code in question.

  • To foster the development of challenge of critical code studies, we need tools for annotating code. This has been one of the longest-running quests of the working group.

    In the past we have tried various platforms. In the first Working Group, we used Google Docs to comment on the code for ADVENTURE, led by Dennis Jerz. In a later workshop, we used Scalar to discuss the Transborder Immigrant Tool and then Taroko Gorge to explore many different pieces of code. Of course, these Vanilla Forums have also served this purpose.

    Lately, I've become excited by Jupyter Notebooks in Google's Colaboratory. This platform allows code readers to see and annotate code in action. Small blocks of code can be embedded into a Google Doc-like page and then compiled and run. Readers can see what the code does and can experiment with changes in a document that tracks changes.

    I've opened up a discussion of them in a separate thread, where I point us to see how we could analyze the python code for Taroko Gorge as well as my new piece of interactive fiction Flight of the CodeMonkeys, in which readers make changes to the code as their interaction. I'm excited to see what kinds of code readings we could build on these platforms.

    Take a look at these platforms, and see what you think of their potential, especially for collective explorations of code.

  • For me the question of understanding code has to do with the ability to, at least partially, open up black boxes that operate in our everyday lives. With the progression of digital media towards algorithmic media, the coding structures are becoming increasingly obscured -- where as one was able to read the variables for Youtube in a Web 2.0 environment, now figuring how the Youtube ranking works requires the creation of a research algorithm in an of itself.
    The exposure of the cultural bias in code is crucial because it exposes the imposition of monocultures both in computer science as well as in research driven through computer-driven methods.

    I am writing as a humanist.

  • @Stefkax said:
    ...With the progression of digital media towards algorithmic media...The exposure of the cultural bias in code is crucial because it exposes the imposition of monocultures both in computer science as well as in research driven through computer-driven methods.

    Excellent point about monocultures. I suppose by extension this has largely lead to a linguistically undiverse, standardized use of natural language elements in programming syntax. Which is odd, considering that people can easily code-switch between natural languages and coin multilingual words and phrases.

    Could you expand a bit more on what you mean by algorithmic media?

  • One question I have is whether the critical reading of Machine Learning datasets and corpora could fall under CCS? On the one hand, datasets and corpora are not code. But on the other hand, code is created in order to read them, and they are used to construct Machine Learning training models which influence machine performance.

    Resources such as datasets and corpora are used to train AI models. Some of these models exhibit unwanted social bias in their performance, and much of this originates in bias which is 'baked into' the resources that the models are trained on. This can include discriminatory bias as expressed in the plain text of news articles which have been scrapped from the web, and which are then compiled into a corpus. Bias can also be caused by class imbalance in a dataset, where an over-representation of one type of data results in a positive bias towards that class. This is of course unethical and harmful when human beings are involved, as is the case when facial recognition exhibits racial bias.

    I believe that taking a view informed by the Humanities enables researchers to ask the right questions about what is present or absent from a resource, to (close)read, and to be able to explain issues discovered in the resources. These critical steps are crucial to do for systems which promise to interface with society and culture. Of course, one can hope that not all Machine Learning resources are or will be problematic; some might be sources or spaces of inspiring and comic juxtapositions and groupings, for example.

    The critical reading of datasets and corpora could be conducted with the help of code tools such as IDEs and short scripts, in order to aid in printing or filtering resources into a more human readable form.

  • edited January 24

    @Lesia.Tkacz said:
    One question I have is whether the critical reading of Machine Learning datasets and corpora could fall under CCS? On the one hand, datasets and corpora are not code. But on the other hand, code is created in order to read them, and they are used to construct Machine Learning training models which influence machine performance.

    Way back in 1976 Niklaus Wirth published a book on data structures and programming languages titled "Algorithms + Data Structures = Programs." In it he argues for the inseparability of algorithmic procedures and data structures as the binary components of programming. Though he is largely addressing structures and techniques, expanding the scope of his equation into the content of the data structure/algorithm binary and its context seems to be precisely what CCS proposes (at least in my noobie naive reading of it).

    One could further ask about the significance of markup languages ("HTML is not code!" is a refrain I've heard from many programmers) and the protocols for library records in particular. This appears already to be a topic in publications relevant to CCS, such as critiques of the Dewey Decimal System and its successors.

  • Dear Participants I have enjoyed this Forum reflections
    CCS are new for me. However after thinking about the introductory chapter and the discussions in this forum, I think that CCS could be useful in the preparation of pre-service and in service k-12 educators. This type of educators’ preparation would support how to integrate programming and the teaching of scientific concepts within a vision beyond of computer science’s concepts and technical knowledge acquisition. The suggestion would be design and implement adaptable educational projects that could inspire non technical academics and k-12 individuals’ reflection based on learning by doing on how computer programming or ‘coding literacy’ can stimulate transdisciplinar technical, cognitive and scientific knowledge acquisition. In practice, it is possible to implement educational projects for inspiring coding literacy utilizing low cost and accessible web3d based information production and visualization technology, bringing about inspiring individuals’ tacit knowledge application and lifelong learning attitudes (FRANCO; LOPES, 2012, https://www.intechopen.com/books/computer-graphics/developing-an-interactive-knowledge-based-learning-framework). I have developed educational experiments with support of k-12 colleagues and students using open source web3D based technologies. Digital resources used have been Gmail as well as Blogger and its Hypertext Markup Language (HTML) editor platforms. Blogger platform has allowed integrating HTML with the Extensible 3D (X3D) language through using the X3Dom framework (https://www.x3dom.org/). Then, it has been possible to design and build interactive 3D virtual reality environments through integrating coding and scientific concepts of k-12 curriculum. So, CCS methods can be applied for individuals’ understanding, for instance, how, when and why teaching and learning spatial thinking with support on geometric and math, mother, foreign and artificial/digital languages, cultural and arts concepts application. For example, I have learned to explore and share Web3D technologies in diverse lifelong learning activities registered in my blog https://musiquarium4000edu3d.blogspot.com / https://midiasnaeducacaoeautoria.blogspot.com/ /https://englishartworkaternaniprimaryschool.blogspot.com/. This type of knowledge can be accessible and understandable to anyone who has basic reading and writing skills. It can mean inclusive and equitable educational opportunities, if we think that the mentioned Web3D technologies have been available through accessible web browsers in smartphones, tablets and personal computers to name a few. For instance, we run educational experiments with 8th grade students from October to November 2019 addressing the theme ‘Health and Life Quality’. Some blog results are https://lauraevellynmariafernanda.blogspot.com/ / https://vitorick.blogspot.com/. Projects like this could be a starting point for implementing computer coding studies at k-12 levels, contributing for individuals prepare within a transdisciplinary mood their cognitive and technical skills for researching, reading, writing, understanding and communicating using more complex computer programming languages.

  • edited January 24

    I think that CCS could be useful in the preparation of pre-service and in service k-12 educators. This type of educators’ preparation would support how to integrate programming and the teaching of scientific concepts within a vision beyond of computer science’s concepts and technical knowledge acquisition.

    I agree that CCS could be integrated into K-12 curricula in order to open up more ways into scientific concepts by demonstrating how the scientific is deeply embedded in the social. I'm not entirely sure what that might look like, but here are some ideas off the top of my head. (Join in others.)

    • Students do a project where they research (or learn) the history of a computer program or programming language.

    • Students port the same small program across many languages to compare their differences.

    • Students learn computer languages in contexts that emphasize their history, for example, Sr. Mary Kenneth Keller's role in the development of BASIC.

    • Students write programs with obvious social implications, a Milgram-esque program that sorts students or perhaps a program that creates "objects" that represent the way adults think of kids. Or perhaps building on that, an assignment in which students create children of an object that have variations on them. Such an assignment could teach object-oriented programming, while thinking about the way life is modeled in code.

    I've tried in the book to explore the stories behind the software and code, whether the tale of leaked climate software or the development of an Arabic programming language. Those stories tend to turn up the social, issues of gender, power, politics, et cetera are in programs. Showing students these stories might help them know programming for the complex social activity it is .

    Consider for example, our Week 2 and Week 3 topics. Looking at indigenous programming languages or feminist AI could increase roads of access to students who might be turned off by communities that feel exclusionary or by content that feels dehumanized.

    Thank you for sharing those projects, btw.

  • What role can CCS play in the lives of working professionals? How can it be applied to our everyday work? What frameworks exist (or need to be built) for this to happen?

    I am not sure how CCS would make someone a better developer. Probably an interest in CCS reflects a deeper commitment to programming, which makes someone a better developer.

    But as a developer myself, I am interested in the creation of culture among programmers and in understanding how software impacts culture creation (e.g., any sci fi film involving programmers). I am also reminded of Marx's incorrect prediction that the proletariate would not be able to create their own culture. A rich working class culture was produced and a similar thing could happen for software development, with some critical reflection (analogous the working class reading Marx et al).

    It also seems that many mature professions have theoretical branches that ground their practices (law, architecture, etc), and CCS can do the same thing for programming.

    In terms of frameworks/platforms, I have been interested in the idea of creating and adding different sorts of 'critical theory' packages to CI/CD platforms. Different critical analyses could be built out programmatically to give feedback on/instrument code.

  • What role can CCS play in the lives of working professionals? How can it be applied to our everyday work? What frameworks exist (or need to be built) for this to happen?

    I think the notion of code as "text" discussed in Mark's introductory chapter can illuminate software of working professionals and help them do their work more effectively. While code execution is important, in some ways, code used in business is ultimately an artifact that documents what an enterprise has "decided" to do as its business plan.

    Code as a business artifact is like a legal document in which both statements that are compiled and code comments - to readers of code and programmers rereading and redacting this code - should not be separated. Everything in the code is a signifying component that attempts to exposit some decision by an institution for which a programmer codes.

    This notion can be extended to code import statements and license preambles as things found in code that should be interwoven with code proper - from a reader or archeologist perspective. But also, a programmer paying attention to everything in code can shape how well this code “reads” as a record of definitive actions of a business or institution. And I guess that’s how a programmer can apply the notion of “text” in everyday work, to effectively accomplish institutional or business tasks (and keep her job!)

    It is true of course that there can be a tension between the programmer and the institution she represents, no doubt. Meaning is never simply or transparently what its authors intend. There is code that subverts the institution it is written for, indeed!

  • @gregorybringman (Welcome back!)

    First, I have to ask, what examples of code can we think of that subvert the institution it is written for? Historical code or your own (don't get yourselves fired!).

    Your comment has me thinking about the way that Critical Code Studies may change the world of the professional programmer. As we study more and more code examples, from the climategate code to the code in infocom game The Hitchhiker's Guide to the Galaxy, it is clear that the audience for the code can be wider than expected.

    What happens when programmers develop with a greater sense that their code will be read by broader and even unintended audiences? Does that create a panopticon of paranoia and performance anxiety? Does that compel more literate programming in the sense that Knuth raises -- the need for beautiful code? Or does that change the way we think of code as not something hidden backstage but the show itself, not the back of the bureau drawers, not mere machinery but the medium of communication that it is. Not the remnant or residue but the centerpiece, the object of inquiry, the treatise, the objet.

    Would that give rise to more code stylists, those who pride themselves on the nature of the code? Greater emphasis on thorough and comprehensive documentation? Greater emphasis not on what the code is meant to do but how it is doing it? Greater sense of code ethics? Or perhaps a whole class of style editors whose job it is to help programmers revise their code. Perhaps such a thing already exists? I apologize if these appear to be nightmare scenarios to those in the profession who already have to deal with meddling managers and other budgetary constraints, whether money or time.

    When I think of that reaction that programmers give me.

    When I approach programmers about interpreting their code, a wry smile arises on their lips. After a bit of discussion, it becomes clear that they suspect I want to read their code as an English major would read a poem by Nikki Giovanni or a sonnet by Shakespeare. Will I treat their methods as stanzas? Their routines as rhymes about roses? Am I elevating their just-in-time or labored code to the status of art? Their smiles reflect their ambivalence about their own code. On the one hand, they tend to dislike their code and feel a certain degree of shame. Perhaps it can be said of code what da Vinci said of art: It is never finished, merely abandoned, meaning that code as a unit of mechanisms is always partial and potential. It can always be improved, developed, reworked, reimagined, and repurposed. On the other hand, programmers seem to feel a degree of bemusement that I would try to understand them through their code, treat them as I would an author, seek their fingerprints or their signature style. But critical code studies is not some grand game of gotcha, nor some return to the harsh critiques programmers received at school, online, or at work. Nor does critical code studies primarily seek to understand and map the mind of the inspired computer programmer as artist.

    Nonetheless, I do think that if programmers more often think of themselves as creating something that could potentially be read widely in varied contexts by those who wish to understand the program and its history, programming itself may change in unexpected ways. And at least in the world of digital arts, it already has.

  • First, I have to ask, what examples of code can we think of that subvert the institution it is written for? Historical code or your own (don't get yourselves fired!).

    @markcmarino, here is a little something from my greatest hits, a code comment that was actually used in a corporate job around 2012-13. The following link is another instance of its use in one of my open source code projects (I hope I've not previously shown this!):

    https://github.com/gbringman/elements-data/blob/master/src/test/java/net/gregorybringman/elementsreduce/types/ElementsMapWritableTest.java

    This is a unit test for a Java hashCode method that lightly comments on the algebraic preconditions of equality / identity, the properties of transitivity, reflexivity, symmetry.

    Note the comment inside the method, "Transitive, reflexive...."

        /*
         * Test that hash codes of identical {@link ElementsMapWritable} objects are
         * equal and that hash codes of different {@link ElementsMapWritable}
         * objects are not equal.
         */
        @Test
        public void hashcode() {
    
            // Transitive, reflexive, symmetric, blah, blah, blah....
    
            Assert.assertTrue(mapWritable.hashCode() == identical.hashCode());
            Assert.assertTrue(identical.hashCode() == mapWritable.hashCode());
            Assert.assertTrue(mapWritable.hashCode() == mapWritable.hashCode());
            Assert.assertTrue(mapWritable.hashCode() == identical.hashCode()
                && identical.hashCode() == identical2.hashCode());
            Assert.assertFalse(mapWritable.hashCode() == different.hashCode());
            Assert.assertFalse(mapWritable.hashCode() == 0);
            Assert.assertFalse(mapWritable.hashCode() == new String().hashCode());
       } 
    

    Instead of stopping at subverting a business, it subverts the institution of computer science that would over-formalize this theory behind a quality control regression constraint. It makes reference to the commonly known algebraic theory, while suggesting a fatiguable but critical eye that stands in contrast to the code that must perform these algebraic properties. It points to mathematics history, the trace of CS theory in business, and Fordist, assembly line associations of boilerplate test code - beyond aestheticization and romantic notions of art.

    Nor does critical code studies primarily seek to understand and map the mind of the inspired computer programmer as artist.

    In CCS, code as text or artifact is written in such a way as to refer to Foucauldian collectives or Bourdieuian entities in a cultural economy of goods, among other post structuralist frameworks that deemphasize genius and individuals. It is not about the inspired computer programmer as artist at all. The difference is like that between a conceptual artist (like Joseph Kosuth or Victor Burgin) and a formalist artist. And writing code for a business that channels and represents that business is similar to the way conceptual artists work with ideas - except that the work is usually strictly more corporate.

    One hope of conceptual art in relation to CCS is that the artifact won't be about style so much, but be constructed in such a way to be played out in a larger world of ideas and culture - with all sorts of social and political ramifications. In historicizing, this approach gives it that wider context to be received and interpreted.

  • I believe that taking a view informed by the Humanities enables researchers to ask the right questions about what is present or absent from a resource, to (close)read, and to be able to explain issues discovered in the resources. These critical steps are crucial to do for systems which promise to interface with society and culture. Of course, one can hope that not all Machine Learning resources are or will be problematic; some might be sources or spaces of inspiring and comic juxtapositions and groupings, for example.

    @Lesia.Tkacz I agree with you 100% that critical code studies approaches will be helpful here.

    If I could advocate for anything, it would be to try to develop a rigorous methodology for performing those close readings so that they are grounded, whenever possible, in what we can measure. Our Week 3 discussion of feminist AI may cover some of this. Certainly @SarahCiston, @CatherineGriffiths, and Christine Meinders, our hosts for this week, have already been wrestling with this.

  • I enjoyed reading the introductory book chapter. I recognized a bit of my own skepticism of CCS in the description of programmers, but I found the examples here pretty compelling and illuminating. I'm still thinking about what CCS means or could mean for my practical work as a programmer - it feels orthogonal to the conversations with team members and the goals of well-written, working, maintainable software that we're trying to build, but a CCS approach might be really interesting and helpful when we work to share our work and approach with a less technical audience (e.g., a recent post I wrote on Coding with Unknowns that actually includes a code snippet from one of our projects).

  • @suttonkoeser said:
    I'm still thinking about what CCS means or could mean for my practical work as a programmer - it feels orthogonal to the conversations with team members and the goals of well-written, working, maintainable software that we're trying to build

    And I think it's important to consider where that vision of well-written code comes from, and under what conditions we'd abandon it, something we've discussed a bit in the FatFinger.JS thread. Much of my favorite work in code art and code poetry favors self-expression at the level of code over clarity.

Sign In or Register to comment.