Howdy, Stranger!
It looks like you're new here. If you want to get involved, click one of these buttons!
Categories
In this Discussion
First time at CCSWG? New to CCS? Start here!
If this is your first time here, I'd like to welcome you.
If you're brand new to CCS, you should know:
Critical Code Studies is an emerging field of study exploring the extra-functional significance of computer source code. "Extra" does not mean outside of the function, but growing out from. Code is the means of a discussion, rather than the ends, the entry point into a discussion of technoculture. CCS is not so much an approach but a growing collection of methods and discourse.
To orient yourself, consider reading
- The Original Manifesto
- The Introduction to_ Critical Code Studies_.
- This analysis of the Transborder Immigrant Tool
If you're brand new to the Working Groups, you should know:
During this biennial event, we dig deep into code and coding culture with a diverse, interdisciplinary community of artists, practitioners, and scholars. The past two CCSWGs are available publically. The previous ones were closed to participants only. However, you can read previous discussions from the first Working Group in electric book review, where this year's weekly discussion was held.
The challenge is to keep the focus on code, but of course, we discuss many aspects of the programs and their contexts. However, at this event we have an opportunity to tackle the hardest part of this interpretive and creative practice. We encourage you to start a Code Critique thread or to join in on someone else's. Remember, you don't need to know what you want out of that discussion when you post that. Our group has enough specialties, interests, and approaches to find interesting gems in it or interesting ideas to discuss related to it.
But let's use this thread for any questions you have about this emerging field!
Comments
One area that I am interested in is the critiques of CCS. I hear a lot of grumbling and side comments about CCS from other programmers, or see rants about it on twitter, but most of them seem to be from an "examining code as a cultural element makes me uncomfortable" perspective rather than a more critical academic perspective. I believe that CCS is a vital field in our digital world, but I am interested to see if anyone has any links to any works that take the more critical academic perspective on CCS so I can look at what the concerns might be.
@annatito that's an interesting observation, i haven't come across those comments in my social media but they are all too familiar. are you asking about artwork specifically? i thought of this publication written by a linguistic: https://github.com/eseyffarth/how-not-to-reverse-a-string
it falls between being playful and critical.
@annatito I haven't seen those comments in a while. Perhaps they're more of subtweets, but I'm happy to discuss with anyone who has discomfort about CCS. I have a lot of experience with that.
Actually, a lot of the introduction to the book Critical Code Studies is a response to concerns I have heard from programmers, and it tries to situate CCS clearly not as an intrusion into the realm of programmers but instead an extension of it. Most programmers regularly engage in part of what I consider CCS, even in terms of cultural critique, they just don't call it that.
If you see any more programmers concerned about CCS, invite them to the Working Group. We'd love to include them in the conversation!
@onebigear It is usually weird side comments that make them hard to engage with directly or knee-jerk responses, when I start to talk about CCS people get it I suppose I am interested in if there are serious academic critiques that can be engaged with rather than this undefined discomfort.
The opening and style of that repo reminds me of the "how to be a very good programmer" manifesto in the code gen library I use: iMatrix GSL: Model Oriented Programming. In this case however the rant is very serious
.
@markcmarino I am also always happy to discuss the discomfort as well and do the translation into programmer speak when needed. If someone has worked in industry I often use the example of a repo check in name. There is always that one historical check in name of a person you have never met but when you hit an issue and see that name you likely know what the issue is or how to find it as you know how that person codes, and you usually don't like it. This is a concrete example that programmers have had but highlights the idea that code is embedded with the programmers way of thinking and not only that but other programmers can tell. This is almost exactly like the interview example given in the first chapter of Critical Code Studies, but I find that it tends to link CCS to their lived experience more directly (you can also make it funny in conversation which makes it less identity threatening
).
In terms of the concerns I suppose I am looking to find some more academically based critiques to respond to rather than the general discomfort many programmers have with the idea that code is a cultural product or that it embeds structures of oppression. I have found specific examples in industry and the open source space (for example this terminology update issue in OpenSSL, I recommend looking at the git repro discussion if you are interested) but these issues seem to comedown to an old guard that holds the power and a new guard wanting to change things rather than a really considered critique. It may be that there is none I was just interested as as I am going into this space in my PhD I would like to be able to respond to or at-least acknowledge legitimate academic critiques if they exist.
@annatito There are some serious critiques that I think point towards CCS, but none that I know of that name it as such. One is Wendy Chun's critique of the concept of source code itself in Programmed Visions, which I think is in part worried about a certain tendency in CCS when it was first starting to think of code as somehow more "real" than software. As the disciplinization of the various digital studies has played out, I think now CCS sees itself as just another lens along with platform studies, software studies, etc., not as having any privileged access to the "real." So that's maybe more historical.
Another thing that might be a critique is David Golumbia's The Cultural Logic of Computation, which thinks of computers as thoroughly cultural entities, but one of the ideological elements of computers for him (IIRC, it's been a while) is the way that we think about code as if it were language, when it isn't actually a language. CCS tends to argue that code is more linguistic than we think, not less, but I think a version of critical code studies which didn't consider code to be a real language might be possible, if you wanted to do that.
The last, which I think is important for everyone adjacent to the digital humanities to read, is Allington, Brouillete, and Golumbia's LARB article here:
https://lareviewofbooks.org/article/neoliberal-tools-archives-political-history-digital-humanities/
Very roughly, it's worried about the turn towards production (and worse, productization) within the humanities and how this may devalue (culturally and with literal funding) other kinds of work which make the humanities valuable.
These three all make serious points that are worth grappling with. But also note that at least two of these authors (WC and DG) have themselves participated in critical code studies events, so I definitely think these are critiques that are about guiding our potentials and direction, not any straight opposition per se.
@annatito I appreciate your effort to get a full sense of the debates around CCS and also @ebuswell 's recap of these previous conversations.
On this introductory thread, I would just note that performing these kind of interpretations of specific lines of code is one of the hardest tasks that techno-cultural critics will attempt. Most scholars will take any opportunity they can, even in a paper about a specific paper about software, to turn away from the code and talk about something else. And understandably so. It's hard to do. That is not to say that 100% of a CCS paper needs to be about specific lines of code. Instead, I mean to say, I understand why people might be tempted to use various objections to CCS as an opportunity to discuss more familiar aspects of software and software (in) culture. Critiques of CCS as well as more abstracted approaches, such as algorithmic studies, have served as academic cover for people to avoid the challenging work of interpreting code.
The reason we still need the CCSWG over 15 years into this project is to help scholars grapple with the meaning of code and develop methods for approaching it in a supportive and collegial environment that makes code, through such features as the Code Critique threads and syntax highlighting in the code snippets in this forum, the center of our discussions. That isn't to put code uber allis but instead to say that we still have much work to do in order to develop methods, vocabulary, and other heuristics for interpreting code. I'm grateful for all who have shown up this year (and continue to show up in people like Evan's case) to try collectively to find meaningful ways to talk about code.
@ebuswell Thanks so much! A lot of great things to look at there.
@markcmarino Thanks for taking the time to respond, you have raised some really good points that I think will need to stew in my mind for a bit.
I know I can find the critique of code particularly difficult because I have the often conflicting lenses of the programmer and someone who is looking at the code from a more cultural studies aspect. One part of my brain will focus on structure as relates to performance, extensibility and maintainability while the other is interested in embedded bias, assumptions and structural norms. Hopefully in time I can learn how to balance the two
@annatito I keep thinking about your comment about the challenge of focusing on performance and other matters while also thinking about "embedded bias, assumptions and structural norms."
I just want to offer that CCS may be closer than you think. While examining that issues of biases and norms is one aspect of this endeavor, it is really only one. Critical Code Studies invites us to explore all of the ways that code comes to take on significance. That includes the way, for instance, cultures of programming communities think about performance or elegance -- or even the way these communities communicate to one another through their choices in choices of architecture or even efficiency. In other words, rather than see the code work and the critical work as two separate aspects of your experience of code, what if we frame them as intertwining, interlinked, and interwoven, so the more you engage with code on one level, the more opens up to you on other levels.
Part of my response is an attempt to widen the sense of what CCS has to offer. Yes, exploring significance leads to issues of social inequity and it also opens up conversations of the material history of programming and it also thinks about the code's meaning evolves as it circulates and iterates and.... Well, there's really no limit.
Critical Code Studies is an encouragement and a context for thinking about code from many vantage points and intersections, all those realms of meaning making and taking that you are participating in whenever you encounter code.
Does that help?
@markcmarino Yes that does. Thinking back I realise that that is the direction I originally came to CCS from. Coming from a background that is outside the norm for a lot of programmers I have found that my approach to code is very different. In my industry presentations on my approach to software architecture I always talk about how to understand an approach to code or architecture you need to understand the thinking behind it. To this end my presentations tends to spend a solid chunk of time exploring the reasoning and the choices that lead to the technical approach. I often joke that to really understand my architecture as it is now you need to understand my approach to maintainability and extensibility (Don't be THAT Programmer: Engineering for quality and maintainability [YouTube Video]), as well as how to architect for live service and mobile games (Architecting for live service games on mobile: A client-side perspective [YouTube Video]) before you can understand my Technomancy (Lessons in Technomancy [YouTube Video]). It is this background that sets the bench marks for what is valued in the system, what is considered "good" and "bad" within the approach and why this is the case.
Some very interesting thoughts bubbling away in my brain
Thanks 