[Commlist] CFP: Source Code Criticism: Hermeneutics, Philology, and Didactics of Algorithms

CFP: Source Code Criticism: Hermeneutics, Philology, and Didactics of 
Algorithms

Algorithms determine our situation. From bubble sort to Google’s Page 
Rank, credit scores, and predictive policing, the logic of algorithms 
intervenes at every step in our lives. Some operate opaquely, shielding 
their inner workings from curious eyes. Others strive to be transparent, 
are shared on repositories like GitHub, and follow an ethics of open 
source accountability. In both cases, however, a more than trivial 
effort is required to understand the source codes in which algorithms 
are usually written. The workshop “Source Code Criticism: Hermeneutics, 
Philology, and Didactics of Algorithms” examines the various ways in 
which code can be read, interpreted, and made accessible to current and 
future readers, and investigates its role both as often impenetrable 
societal force as well as a very particular type of text.

In the widest sense, any chain of operation including human and 
non-human elements requiring symbolic operations is an algorithm. In a 
narrower sense, however, when we speak of algorithms, we usually mean 
the texts of higher-level programming languages like Python, Java, or 
C++. As text, source code is anything but ordinary. It acts as an agent 
in complex chains of operations and its effects are not confined to the 
computer alone but impact social, legal, and economic relations in the 
real world. Algorithms are thus social constructs functioning at the 
interfaces between humans and machines, implemented in concrete 
platforms and written by actual humans. A hermeneutics of algorithms has 
to take this social reality of source codes into account in addressing 
such questions as: What is the ontological status of algorithms? What is 
their social, legal, and economic agency? And in what constellations is 
their apparent objectivity at odds with their cultural embeddedness?

Codes are peculiar texts in other ways as well. They perform actions 
when executed, reducing expressive language to pure imperatives applied 
to otherwise inert data structures. They are thus at the same time more 
than and less than ordinary language, requiring a philology that is 
equally at home in computer science as in textual criticism. However, 
source code is by its very nature already deeply philological: If 
philologists contextualize and enrich the source text through 
commentary, programmers habitually integrate such commentary into their 
source code. As non-executable lines that are skipped by the compiler, 
comments are used to elucidate the workings of the code to their current 
or future readers. Computer scientist Donald Knuth first formulated the 
idea of software development as a kind of philological critique and 
proposed that source code should be as intensely documented as possible, 
thus rendering algorithms self-explanatory, transparent, and 
comprehensible not only for their authors but also for later readers and 
editors. The workshop wants to ask what it would mean to take Knuth’s 
challenge seriously as a philological practice. What could such a 
“source code criticism” look like? And can we imagine it as a 
retrospective task for researchers to actively intervene in the source 
code and add extensive commentary to it?

Finally, unlike ordinary text, the performative element of source code 
also invites us to intervene in it and explore its scope, possibilities, 
and affordances. Textual criticism and hermeneutics thus become 
practical and interactive. Such interaction addresses one of the main 
tasks of the current humanities – to develop a familiarity with coding 
as such that bridges the gap between the computer sciences and the 
interpretative disciplines. Code literacy is sorely needed in the 
humanities. At the very least, as a passive skill: You don’t have to be 
a literary critic in order to read a novel. Nor do you need to be a 
computer scientist in order to understand and critically read software 
code. Yet digital literacy is a critical faculty necessary to 
understand, disclose, classify, contextualize, and explain code in order 
to counter the much-invoked power of algorithms. In order to recognize 
how exactly a user is used by software, it is necessary to decipher, 
comprehend and critically uncover the design and construction of an 
algorithm.

The workshop addresses scholars within and outside fields such as 
Critical Code Studies, Software and Platform Studies and media studies, 
and it invites contributors to comment on the hermeneutics, philology, 
and didactics of code. The papers should not exceed 30 minutes and 
should be delivered in English.

Please send an *abstract* *of no more than 500 words* and a *brief 
biographical note* to (hannes.bajohr /at/ unibas.ch) 
<mailto:(hannes.bajohr /at/ unibas.ch)> by *October 31st*.

The workshop will be held on *March 25, 2022* as a hybrid conference in 
person in Basel, Switzerland, as well as over Zoom.

---------------
The COMMLIST
---------------
This mailing list is a free service offered by Nico Carpentier. Please use it responsibly and wisely.
--
To subscribe or unsubscribe, please visit http://commlist.org/
--
Before sending a posting request, please always read the guidelines at http://commlist.org/
--
To contact the mailing list manager:
Email: (nico.carpentier /at/ vub.ac.be)
URL: http://nicocarpentier.net
---------------