Software Libraries:
Following the Infrastructures of Code

20 Jul 2026

CfP: Special Issue for Computational Culture, a Journal of Software Studies

Description

A programmer who needs to build a website with a login form will not write from scratch the code that encrypts the password and manages the user's session. Instead, they can import software libraries that already solve these tasks, for example bcrypt to encrypt the passwords and Flask to create the web server. With a single command in the terminal, pip install flask bcrypt, they can install these libraries and make them available in their project. As explained by David Berry (2011, p. 40), nowadays “code is written through a process of collage, whereby different fragments of code (usually called ‘#includes’) are glued together to form the final software product.” This imported code, known as software libraries, contains modular functions created and maintained by other people, companies, or foundations (Fink et al., 2020; cf. Krysa & Sedek, 2008).

These libraries reduce programmers' workload and allow them to focus their attention on the functions specific to their software, rather than recreating functions that are already widely used. Libraries thus operate as central infrastructural objects of computing, defining how a range of computational practices can develop (cf. Bowker & Star, 1999; Sandvig, 2013). Although they are not visible to end users and frequently recede even from developers’ own awareness, libraries play a fundamental role in organizing sociotechnical relations. They have direct impacts on how problems are defined and systems are programmed. The field of software studies is therefore central to understanding this materiality of code and how it is part of a social, collective construction (cf. Chun, 2011; Berry, 2011; Mackenzie, 2025).

Because decisions about how libraries are developed directly shape how future information systems will function, there is often wide debate and preparation. In widely used libraries, such as the scientific computing library numpy, decisions are made by a large community of developers and maintainers. Potential changes are debated extensively because they may alter how the library is used by thousands of projects around the world. The popular user interface library React, by contrast, is maintained by Meta, while the well-known Artificial Intelligence library Transformers is maintained by Hugging Face.

Software libraries must therefore be understood as sociotechnical, through both their code and their political economy: how they are funded, standardized, and operated. Are these essential code infrastructures becoming platformized (Plantin et al., 2018; Bounegru & Gray, 2024), given that Big Tech platforms have come to define the way essential functions are standardized? The intersection between infrastructure, platform, and software studies makes it possible to interrogate libraries both as programmable artifacts open to reappropriation and in their normative function in the organization of sociotechnical relations across different contexts of use.

This Special Issue addresses the underresearched topic of software libraries by inviting submissions on topics that may include:

Schedule

500-word abstracts should be emailed to Gabriel Pereira ([email protected]) and Abel Guerra ([email protected]) by October 15, 2026. Abstracts will be reviewed by the special issue editors and the Computational Culture editorial board.

Authors of selected abstracts will be notified by November 15, 2026 and invited to submit full manuscripts following a workshop (see below).

A (hybrid) workshop for authors of selected papers will take place early February 2027 at the University of Amsterdam, to enable peer feedback prior to final submission.

The full manuscript will be due April 1, 2027. These manuscripts are subject to full blind peer review according to Computational Culture’s policies. Possible costs for proofreading incurred by the authors are not covered by the editors or the journal. There are no open access or processing charges for this special issue.

The publication of the Special Issue is envisioned for October 2027.

Computational Culture is an online open-access peer-reviewed journal of interdisciplinary enquiry into the nature of cultural computational objects, practices, processes and structures.

Any queries can be addressed to the special issue editors: Gabriel Pereira ([email protected]) and Abel Guerra ([email protected])

The CfP is also available on the Computational Culture website.

References

// Play with the code yourself on: https://editor.p5js.org/gabrielopereira/sketches/204GPZgkP


const PAL = { ground: "#7c7f82",
  a: ["#efece2", "#E7C81C", "#CF3A22", "#2C6BB2", "#141414"] };
let s, cols, rows, fx, fy;
function setup() {
  createCanvas(windowWidth, windowHeight);
  noStroke();
  noLoop();
  reseed();
  gridLayout();
}
function reseed() {
  const k = Math.floor(Math.random() * 99999);
  noiseSeed(k);
  randomSeed(k);
}
function gridLayout() {
  s = Math.max(20, Math.min(width, height) / 15);
  cols = Math.ceil(width / s) + 4;
  rows = Math.ceil(height / s) + 4;
  fx = width * 0.72;
  fy = height * 0.78;
}
function warp(x, y) {                 // swirl toward a focus + domain warp
  const dx = x - fx, dy = y - fy, r = Math.hypot(dx, dy);
  const a = Math.atan2(dy, dx) + 1.15 * Math.exp(-r / (s * 6));
  const sx = fx + r * Math.cos(a), sy = fy + r * Math.sin(a);
  const nx = noise(sx * 0.004 + 10.2, sy * 0.004 + 3.1) * 2 - 1;
  const ny = noise(sx * 0.004 + 42.7, sy * 0.004 + 8.6) * 2 - 1;
  return [sx + nx * s * 0.6 + (sy - height * 0.5) * 0.06, sy + ny * s * 0.6];
}
function colorFor(cx, cy) {           // smooth, quantized -> merged shapes
  const v = 0.6 * noise(cx * 0.019 + 5, cy * 0.019 + 1)
          + 0.4 * noise((cx * 0.6 + cy) * 0.014 + 21, cy * 0.010);
  if (v < 0.30) return PAL.ground;
  const k = noise(cx * 0.016 + 70, cy * 0.016 + 30);
  return PAL.a[k < 0.22 ? 0 : k < 0.46 ? 1 : k < 0.68 ? 2 : k < 0.88 ? 3 : 4];
}
function draw() {                     // warp every node once, then fill cells
  background(PAL.ground);
  const ox = -2 * s, oy = -2 * s, W = [];
  for (let j = 0; j <= rows; j++) {
    W[j] = [];
    for (let i = 0; i <= cols; i++) W[j][i] = warp(ox + i * s, oy + j * s);
  }
  for (let jj = 0; jj < rows; jj++) {
    for (let ii = 0; ii < cols; ii++) {
      const x0 = ox + ii * s, x1 = ox + (ii + 1) * s;
      const y0 = oy + jj * s, y1 = oy + (jj + 1) * s;
      const A = W[jj][ii], B = W[jj][ii + 1], C = W[jj + 1][ii + 1], D = W[jj + 1][ii];
      if ((ii + jj) % 2 === 0) {
        fill(colorFor((x0 + x1 + x0) / 3, (y0 + y0 + y1) / 3));
        triangle(A[0], A[1], B[0], B[1], D[0], D[1]);
        fill(colorFor((x1 + x1 + x0) / 3, (y0 + y1 + y1) / 3));
        triangle(B[0], B[1], C[0], C[1], D[0], D[1]);
      } else {
        fill(colorFor((x0 + x1 + x1) / 3, (y0 + y0 + y1) / 3));
        triangle(A[0], A[1], B[0], B[1], C[0], C[1]);
        fill(colorFor((x0 + x1 + x0) / 3, (y0 + y1 + y1) / 3));
        triangle(A[0], A[1], C[0], C[1], D[0], D[1]);
      }
    }
  }
}
function mousePressed() { reseed(); gridLayout(); redraw(); }
function windowResized() { resizeCanvas(windowWidth, windowHeight); gridLayout(); redraw(); }