Cultures of Programming

A Companion Exhibition to the Book

• Tomas Petricek, tomas@tomasp.net

• Andrew Goodall, Jaroslav Nesetril, curators
• Galerie Chodba, December 2025—April 2026

• Would you like to display this exhibition at your university or a conference? Drop me an email!

This exhibition looks at the history of programming through a perspective introduced in the Cultures of Programming book. In 14 posters, it illustrates the five different basic ways of thinking about programming and documents a number of remarkable collaborations and disagreements between the five cultures.

History of Programming

A New Look at the History

This exhibition tells the story of how interactions and disagreements between the different cultures of programming shaped programming concepts and methodologies that programmers use today, including programming lang­uages, types and objects, software engineering, and interactive programming.

It follows the evolution of these concepts and methodologies from the early days of programming to recent times and interprets the key developments in terms of interactions between cultures of programming. The interpretation reveals two interesting aspects of the development of programming.

First, many programming innovations happen when multiple cultures meet and contribute to a single concept or methodology. Second, individual cultures of programming retain a remarkably strong identity throughout the history, marking programming as an inherently pluralistic discipline.

The opening panel presents the exhibition and the book. It introduces the key premise of the exhibition—looking at the history of programming as interactions between five different cultures of programming. The exhibition follows a different structure from the book, dedicating a panel to each of the individual cultures, before focusing on a few selected interactions between cultures.

The Cultures of Programming panel illustrates the five different cultures of programming with one paradigmatic example for each culture. For managerial culture, the large scale of systems is a typical trait, whereas creative ideas on education are often linked to the humanistic culture. Using a chalk and blackboard for reasoning about programs characterises the mathematical culture, while the engineering culture sees programming as a complex task requiring professionalism. Finally, the hacker culture tends to push the limits of what is possible, not always with serious goals in mind.

There are many excellent books on the history and philosophy of programming and computing. The panel History and Philosophy shows just a few of those. It includes a number of books that defined some aspect of the field, technical accounts of specific aspects of the history of programming, as well as books that use the perspective of social studies to uncover how hidden biases, power structures and rhetoric reshape computing. My account in Cultures of Programming aims to be more historical than a typical technical book and more technical than a typical historical book.

Five Cultures of Programming

Different Ways of Thinking about Programming

The first computer programmers came from a range of backgrounds including mathematics, electrical engineering, business and psychology. Those disciplines shaped many of their basic assumptions about programming, what kind of task it is and how it should be done. Those different ways of thinking about programming that I refer to as cultures of programming continue shaping programming to this day. The cultures clash over basic principles, but also contribute to shared programming concepts. Their basic assumptions remain at the core of current contentious debates about programming.

In the first part of the exhibition, we look at the basic beliefs of the five different cultures of programming—mathematical culture, hacker culture, engineering culture, managerial culture and humanistic culture.

The Mathematical culture sees programs as formal mathematical entities and believes that mathematical methods can tackle the increasing complexity of software systems. The panel illustrates this way of thinking by highlighting two of its achievements. The Algol language, illustrated through a diagram describing its syntax, was regarded as an "object of stunning beauty" and provided a common language for theoretical computer science. The mathematical focus played a key role in establishing computer science as an academic discipline within the modern university.

The panel gives a brief overview of the work of four computer science pioneers. John McCarthy first envisioned a mathematical theory of programs; Peter Naur and C. A. R. Hoare were the first to develop methods for formally proving properties of computer programs; while Peter Landin pioneered the use of the lambda calculus, a formal system developed in the 1930s in the context of mathematical logic, as a model of programming languages.

In contrast, the Hacker culture values direct engagement with the nitty-gritty details of program execution. The panel illustrates the values and practices of the hacker culture. The Spacewar! game was a project born out of the desire to have fun with computers, but it was also a demonstration showing what can be achieved through ingenious programming with the limited computing power of the 1960s. Hackers were also the first to explore interactive ways of program­ming, illustrated through the TX-0 computer, which was installed at MIT and allowed programmers to directly engage with the machine, rather than submit their programs as batches of punched cards. The hacker culture also often distrusts existing structures and early computer hackers preferred to share their knowledge freely on the ARPANET (predecessor of the Internet) rather than in established academic venues.

The Engineering culture sees programming as an applied engineering science. It recognises programming as a challenging human activity and aims to build tools and create practices to tackle the task. The panel illustrates some of the challenges of establishing the software engineering discipline and its narrative. Referring to failures as "bugs" suggested that they are small issues, easily dealt with, despite the astonishing cost of some of the software failures. One such challenging project was the development of anti-ballistic missile software systems throughout the Cold War period. The various software efforts helped the engineering culture establish its own language for understanding what kinds of software can be reliably built.

The history of software engineering often centres around key moments including the 1968 NATO Conference on Software Engineering and the meeting that led to the Agile Manifesto. These embody the ideals of the engineering culture, but they happen amidst a broader and richer historical context.

The Managerial culture originated in the military and business organizations. Their managers saw programming as a controlled production-like process. Programs should be created according to specifications, with a predictable timeline and budget. The panel illustrates the managerial efforts through two system examples. The Semi-Automated Ground Environment (SAGE) was a radar air-defence system built in the 1950s of an unprecedented complexity at the time. The IBM System/360 was a family of computer systems, along with a newly developed operating system, created by IBM in the 1960s. Both of these projects posed a major challenge and prompted reflections on the managerial processes for building software systems.

The panel illustrates the different processes for building software systems through the diagrams specifying the steps of the processes. The first such diagram was created already in the mid-1950s as part of the SAGE project; the widely known Waterfall development model described the development as a series of successive steps; while the Spiral development model proposed a process that repeats the basic four steps in a number of iterations.

The primary concern of the Humanistic culture is the human. This can take a wide range of forms and the panel illustrates the somewhat chaotic nature of the culture with the equally chaotic arrangement of some of its key ideas, concerns and projects. The three illustrations in the panel exemplify three typical concerns.

Alan Kay saw programming as a new medium that can convey the excitement of thought and creation. The sketch of children exploring ideas with Dynabook in the panel illustrates the 1970s vision of creating a personal computer for children of all ages. The 1980s HyperCard application for the Apple Macintosh is another example aiming to enable knowledge sharing and was the spiritual predecessor of the World Wide Web. Finally, the humanistic culture has also often turned to art in order to prompt critical reflections on the nature of computing, as well as human perception.

Origins of Programming Concepts

Collaborations and Struggles for Control

The first programmers in the 1940s were controlling the ENIAC computer by plugging cables to connect the individual components of the machine. Even after programming became a matter of specifying the program instructions on a punched card, programmers did not initially think of the codes as a lang­uage. Programming concepts familiar to programmers today, including that of a programming language, a type, or an object had to be invented.

In the second part of the exhibition, we look at how interactions between different cultures of programming gave rise to program­ming languages, types and object-oriented programming, how the concepts evolved amidst disagreements between cultures and struggles for controlling the meaning of the concepts. The hypothesis put forward in Cultures of Programming is that the coexistence of multiple ways of thinking about programming enabled developments that might not have happened without this messy plurality.

In The invention of a programming language, we look at how the concept of a programming language emerged as a standalone entity that can be studied independently of a specific computer or an implementation. Three of the illustrations in the panel represent the three cultures that made key contributions to the concept.

Throughout the 1950s, the hacker culture, illustrated by the first ENIAC programmers, developed automatic coding systems that made it possible to control computers using pseudo-codes not directly recognized by the machine. These were interpreted or translated to actual machine instructions. At the same time, the linguistic metaphor became popular for thinking about programming and the mathematical culture adopted a theory of formal languages for describing the structure of a programming language. Last, but not least, the managerial culture had a practical need—to build programs that can be run on multiple different computers. The ideas from the three cultures combined to give rise to the idea of a programming language, and the astonishing number of languages developed throughout the 1960s, as shown by the popular Tower of Babel illustration.

The Programming with types panel chronologically documents how the idea of type appeared in programming languages and how it was transformed by different cultures over time. Today, computer scientists link types in programming languages to Bertrand Russell's work on types in the context of logic. Historically, the way types were adopted for programming was more roundabout.

There are multiple different origins for what would eventually be known as types in programming. Modes in FORTRAN distinguished between fixed-point and floating-point numbers, but were a product of the hacker culture. Managerial culture was more concerned with data storage, as illustrated by an IBM COMTRAN data description card and the filing cabinet. Engineering culture adopted types as an abstraction mechanism—using types not to describe the set of possible values, but to restrict what operations can be applied to a value.

The many different ideas on types coalesced in the ML programming language in the 1970s, which adopted types in a form linked to their mathematical origins, both for modelling data and as an abstraction mechanism. But the unity did not last long. Mathematical culture developed a new more formal notion of types for interactive theorem proving, while the engineering culture adopted a pragmatic view on types, violating the formal assumptions of the mathematical culture.

The history of Object-oriented programming illustrates another pattern of interactions between cultures, where the concept emerges in the context of one culture, but is then adopted and transformed by another culture. In the case of object-oriented programming, this happened multiple times.

The notion of an object first appeared in the Simula language, created in the 1960s for building programming simulations. Simula was rooted in the mathematical culture and modelled the simulated world in terms of activities and processes corresponding to later classes and objects. In the 1970s, Smalltalk developed a humanistic perspective on object-oriented programming, viewing it as a flexible communication medium between the human and the machine. However, the practical virtues of object-oriented programming were recognized by engineers in the 1980s and even managers in the 1990s, who adopted it as a method for structuring large software systems and development teams, respectively.

Perspectives on Programming

Disagreements About the Basic Assumptions

The different ways of thinking about the nature of programming, represented by the five cultures, can contribute to shared technical concepts, but they also lead to basic disagreements about its limits and its methodologies. Debates about programming education, best ways of achieving program correctness and the possibility of formally verifying software are often rooted in such disagreements.

In the final part of the exhibition, we look at three questions that illustrate the disagreements—What is the problem of programming? What code is beautiful? and How can programming be used to create art? The panels on beauty and art develop ideas that are only side notes in the book, but that vividly reveal how the different cultures think about programming.

What is the problem of programming? The first panel in the series looks at the answers we get if we ask the proponents of the five different cultures a basic question about the nature of programming. Even though the work of many (if not most) figures in the history of programming spans multiple cultures of programming, the panel picks one illustrative quotation for each of the cultures.

The mathematical culture views programs as formal entities and is keen to point out that testing cannot prove the absence of bugs; only a formal proof can. The hacker culture views programming as a craft, requiring hands-on practice and personal knowledge. The engineering culture rejects both of these views and instead sees programming as an applied science, requiring rigorous practices. The managerial culture also seeks rigorous methods, but sees programming primarily as the problem of people management, looking for ways of structuring teams and workloads. In contrast, the humanistic culture sees programming as a new kind of literacy or a tool for assisting human thought, making the human its primary concern.

If we ask the advocates of the different cultures What code is beautiful? we get five very different answers. The answers illuminate the values of the different cultures. For the hacker culture, beautiful code is code that cleverly uses the capabilities of the machine, even if that makes it difficult to understand for a human. This is the case of the inverse square root function from the Quake III game. The mathematical culture applies the criteria of mathematical elegance. Beautiful code should achieve a lot by an elegant combination of a small set of features. This is a characteristic that many associate with the design of Algol 60. In contrast, the engineering culture values readability and understandability and appreciates well-organised code structure, like the one that became known as the Model-View-Controller design pattern.

For the humanistic culture, the beauty of code lies in what it can communicate to the reader. This relies on the fact that code expresses meaning on two levels, first as instructions for the computer and, second, as text read by a human. Similar playfulness can be found in Václav Havel's poem shown in the panel—the meaning is hidden in the crossed-out line. Humanistic culture exploits the double coding in code poetry (as shown in the panel), but also, for example, in the design of esoteric programming languages.

Finally, the panel on Programming and computer art compares three different ways in which programming has been used to create visual art and music. The work of computer art pioneer Frieder Nake in the 1960s was linked to the mathematical culture as it explored the artistic potential of algorithms to generate art, as in the black-and-white plotter print Homage to Paul Klee.

With the rise of microcomputers in the 1970s, it became possible to use computers interactively to control music synthesis. This was explored by The League of Automatic Music Composers (later called The Hub), who connected their computers in a pattern illustrated by the diagram. Each computer was responsible for some aspects of the generated music, but was also sending messages to all other computers in the network, who responded by changing the aspects they were controlling. In this setup, interesting patterns emerge as the result of the interaction, but what emerges is not prescribed by a single given algorithm.

The move from a mathematical culture to the humanistic culture was completed with the emergence of live coding in the 2000s. The panel illustrates this with a photo from a 2023 Algorave performance in the Netherlands. In live coding, the performer enters code live on stage and immediately executes it. The program is not a formal mathematical entity, but a living and evolving object. Live coders often start and end with an empty file.

Notes and Credits

Visuals and Images in the Panels

The design of all the panels follows roughly the same structure. Each panel includes a subtle background that is, in some way, representative of the topic presented in the panel. The images in the panel are photos from a range of archival sources, illustrations adapted from published papers and other materials. The credits for the image sources, as well as the background graphics, are listed below for each of the panels.