In software engineering, people spent a long time divided into two camps: Object-Oriented Programming and Pure Functional Programming. To be fair, we divided into camps rather frequently, but I’ll focus on those two. These were perceived almost as competing moral philosophies, with cultures as different as Enterprise and Academia, or ostensibly Startup and FinTech. If we squint our eyes, we could arguably see two centers of gravity:

  • West Coast (the Valley, Xerox PARC, Alan Kay, and Smalltalk-72), vs.
  • East Coast (MIT, Lisp, and Scheme) on the other.

Though there wasn’t really such a clean separation between them, these were movements of their own, with proponents and detractors.

Hand-drawn outline map of the United States with a pin at Xerox PARC, labeled Smalltalk-72, and a pin at MIT, labeled Lisp 1958, Actors 1973, and Scheme 1975. Two crossing arrows span the country: one from Lisp to Smalltalk-72, marked eval, and one from Smalltalk-72 to Actors, marked messages. At MIT a short arrow marked closures runs from Actors to Scheme. A dashed line from Simula 67, Oslo, enters from the Atlantic and reaches both coasts.
Two coasts in the history of programming, Smalltalk at Xerox PARC and Lisp, Actors, and Scheme at MIT, with Simula arriving from Oslo.

To see them as competing visions, we’d have to ponder why: Why do object-oriented and functional programming feel like such different ways of thinking? Both can solve many of the same problems, but we could say the same for cubism, expressionism, and impressionism in painting. Their value isn’t so much in being able to perform (painting or coding), but in what gets highlighted in representation. You take a subject, or a problem space, then cast your solution into it—but through which medium or frame? If we return to OOP and FP with that question in mind, we can begin to see how each gives us a different way to represent a problem. These are two programming paradigms: one follows an entity through time, the other follows transformations. Both turn bits into something we recognize, and both inherit ideas about what a thing is, how it changes, and how it relates to others.

Notice that what a thing is is such an omnipresent thought that, naturally, we have been asking these questions long before computers. But the same questions elsewhere preceded software and inevitably influenced it, because what we call software is less of a natural science and more a form of expression, like painting, like writing, made by people from a place and a time, who build communities and develop expectations together.

Perhaps if we look at software engineering as a conversation through time, we can understand how it came to be what it is today, and where it may lead.

But I’m getting ahead of myself. Let’s explore these two further.

Objects, identity, and agency

Object-oriented programming gives us a way to organize software around entities with identity, state, and behavior. An object can change while remaining the same object. Encapsulation, for example, draws a perimeter that mediates how the outer world interacts with the internals of an object, much like we do with city walls, sea ports, and border crossings.

But certainly the wall doesn’t make a city, as walls may fall. Nothing specifically makes the city, not the citizens at a given point in time, who come and go like the water of a river, nor the features of the land. What makes the city is that which can be traced across all of them. In the fourth century BCE, Aristotle had a terminology we can associate with OOP: substance with an instance, species with a class, qualities with attributes, and substance persisting through change with an object preserving its identity.

That question, of what makes a thing only this particular thing, wasn’t settled then, almost as if we had to develop the linguistic technology to continue arguing about these subjects at a greater depth. It is in part because of attempting to answer these questions that Aristotle has been held in such high regard by essentially all forms of society since his time, though Aristotle himself having to answer that question is evidence that it was critical, for he was no less than, perhaps, the greatest scholar of his time, before there was academia as we know it, and tutor to Alexander the Great. Centuries passed. Around 1300, Scotus, at Oxford and Paris, explored it through haecceitas, or thisness; then in the seventeenth century, Leibniz’s principle of the identity of indiscernibles held that two numerically distinct individuals cannot be alike in every respect.

By the late nineteenth century, questions of membership and relationship were taking new mathematical forms. Cantor helped establish set theory, and Frege developed a formal language for logic. In The Concept of Nature (1920), Whitehead turned attention toward events rather than enduring objects.

In France after WWII, existentialists including Sartre and Beauvoir explored existence and freedom. For them, the nature of a person could only be determined from their actions. Later, Structuralism emphasized how signs and practices acquire significance through their relations within a system, independently of explicit, premeditated decisions that people might have made. Inspired by Saussure’s account of linguistic differences, Lévi-Strauss extended structural methods into anthropology, and by 1962 he was arguing with Sartre himself. For the structuralists, identity and action could be understood through relationships: through the languages, practices, and structures in which people find themselves.

In the 1960s, Ole-Johan Dahl and Kristen Nygaard developed Simula to model systems of discrete events, whose parts act, interact, and change over time. Simula helped establish object-oriented programming, influenced Smalltalk, and with it contributed to the Actor Model. Alan Kay recalls that Smalltalk also drew on abstract algebra, biology, Leibniz’s monads, and Plato’s discussion of dividing nature at its joints. It drew on Lisp, too. Kay dedicates his history “to SKETCHPAD, JOSS, LISP, and SIMULA, the 4 great programming conceptions of the sixties,” and remembers that the biggest hit for him in late 1969 was finally understanding Lisp’s eval. McCarthy had described Lisp in Lisp in about a page; Kay boasted he could do the same for objects, and that boast became Smalltalk-72.

Three handwritten questions on the left, each with names beneath it: what makes a thing itself? (Aristotle, Scotus, Leibniz); how do things relate? (Saussure, Lévi-Strauss); what does it do? (Whitehead, Sartre). Dashed lines lead from each question into a circle labeled an object, to the words identity, relations, and behavior.
Three older questions that reappear in an object.

But if the city isn’t any particular instance that we may visit, could we say the city is that which satisfies the behavior of a city?

Functions, relationships, and composition

Pure functional programming focuses on relationships between inputs and outputs. Its cornerstone is the pure function, which reliably produces the same result for the same inputs, whatever the circumstances around it, without side effects. This notion comes from modern mathematics, where a function assigns exactly one output to each permitted input.

Amongst its key terms, composition lets us build a larger transformation from smaller ones: the output of one function becomes the input of another.

The familiar notation for functions, f(x), comes from Euler, but people studied relationships between quantities long before him. In an appendix to Euclid’s Elements, we find the Greek word synthesis (σύνθεσις), meaning putting together or combining, although this was not yet composition of functions in the modern sense. Galileo’s work on motion and Descartes’ algebraic treatment of curves made relationships between varying quantities increasingly explicit. Then, Leibniz used the word “function” in connection with geometry, and Johann Bernoulli (1718) described a function as a quantity composed, in any manner, from a variable and constants. Euler would later develop this into a more systematic treatment of functions, making them central to mathematical analysis.

But when did the concept move from mathematics into the structure of thought itself? Since Aristotle, much of logic had followed a subject–predicate structure. For example: “Socrates is mortal”. A proposition was understood as saying something about something, distinguishing the subject (Socrates) from the predicate (is mortal).

Sometimes it takes someone bold to, like Shakespeare, introduce a new terminology or perspective that later changes the course of an entire language. That person was Gottlob Frege, who, in his 1879 Begriffsschrift, introduced a different way of analyzing propositions. Instead of assuming that their logical structure must follow the distinction between subject and predicate, Frege proposed analyzing expressions through functions and arguments. The function (for example, “is mortal”) is incomplete until supplied with an argument (for example, Socrates). Thus: Mortal(Socrates). Socrates can be named independently, but mortality, understood here as the concept “is mortal”, leaves something open. It needs an argument. More importantly, the same proposition could be analyzed in different ways, depending on what we treated as the function and what we treated as its argument. What had previously been understood through the apparent structure of language could now be investigated through the logical relationships between its constituents.

This was an epistemological recentering, not because relationships had suddenly been discovered, but because the mathematical language of functions was now being used to reconsider the structure of propositions themselves. Frege would later develop his distinction between complete objects and incomplete functions, and his account of thoughts (Gedanken) as objective contents, rather than private psychological events. While Frege received relatively little recognition during much of his lifetime, his work would eventually be recognized as foundational to modern mathematical logic and analytic philosophy. Bertrand Russell and Ludwig Wittgenstein built important parts of their work through engagement with Frege, while Giuseppe Peano and others were developing related formal approaches to mathematical reasoning. What followed was not a single school of thought, but a growing recognition that logic itself could be investigated mathematically.

So, by the early twentieth century, names such as George Boole, David Hilbert, and Kurt Gödel were already part of the intellectual landscape, each contributing in different ways to the formalization of logic and mathematics. Mathematicians had algorithms, recursive definitions, symbolic logic, mechanical calculators, and human beings whose occupation was literally to compute. What they did not yet have was a generally accepted mathematical definition of computation itself. In that context emerged Alonzo Church, who, beginning in 1932, developed lambda calculus as part of an attempt to establish the foundations of logic. It provided a formal language for defining and applying functions, where functions could themselves be passed to other functions or produced as results. Related work by Moses Schönfinkel and Haskell Curry had already shown how functions could be built from combinations of simpler operators. But as Church and his students investigated what lambda calculus could express, a more fundamental question emerged: could every effectively calculable function be described through such a formal system? By 1936, Church had proposed an answer, while Alan Turing independently approached the same problem through a model of mechanical computation.

A few decades later, John McCarthy developed Lisp for symbolic computation, beginning in 1958, bringing ideas from recursive function theory into a practical programming language. Peter Landin would further connect lambda calculus with the structure of programming languages during the 1960s. Functions had become a way to express computations, and increasingly, to construct programs.

The missing key wasn’t the function, nor composable structures anymore. What remained was a peculiar habit: computers executed instructions, and programming languages had largely grown around describing those instructions. We had learned to name transformations, apply them, compose them, and reason about them mathematically, but our programs still largely described how machines should move things around. Backus would later observe that much of the traffic between a computer’s processor and memory is not useful data, but names of data and operations used to compute those names. The challenge was now to focus on what programs do, rather than continuously describing the states through which their execution passes.

Let’s go back to language itself. Verbs help us understand nouns for what they do, and thus allow us to say that a tree “greens” and not merely that a tree is green. The Stoics had already distinguished between bodies and the events that happen to them. A tree is a body, but greening is an event. This distinction had been developing in different forms and across different domains.

In France, Albert Lautman had been arguing that mathematical theories emerge in response to recurring problems, among them how the local relates to the global, and how the continuous relates to the discrete. For him, each theory was one way of working one of these problems out, rather than mathematics being merely a collection of established objects and their properties. His work would later influence Gilles Deleuze, who, in The Logic of Sense (1969), returned to the Stoics’ distinction between bodies and events. For Deleuze, the verb expresses the event, what happens to a body without being reducible to one of its qualities or states. “To green” is not simply another way of saying “is green”. It draws attention to the happening itself.

Back in computer science, John Backus was confronting a different problem. Programming languages could already express functions, and functional languages had already begun to emerge, but most programming remained organized around instructions that manipulated state. In his 1977 Turing Award lecture, published in 1978, Backus proposed FP systems, where programs could be constructed by combining existing functions and reasoned about through an algebra of programs. His proposal wasn’t simply to make functions available to programmers, since they already were, but to make their combination the organizing principle of programming itself. Rather than describing every intermediate step through which data must pass, one could construct a larger operation from smaller ones and reason about the resulting program through its mathematical properties.

Two hand-drawn panels. Left, headed one word at a time: a box labeled CPU joined to a box labeled memory by a narrow tube carrying x, addr, i, addr, y, with the note mostly names of data. Right, headed Backus, 1978: data passes through boxes f, g, and h to a result, with the note programs built from functions.
Programs that Backus proposed to build from functions.

In the years that followed, several approaches to functional programming continued to emerge. David Turner’s SASL and KRC, along with later languages such as Miranda, had demonstrated how programs could be written through functional definitions and evaluated lazily. ML, Hope, and other languages contributed different approaches to types, functions, and program construction. But these developments also produced a fragmented landscape, with researchers creating different languages to investigate closely related ideas.

In 1987, researchers working with Alfl at Yale, Lazy ML at Chalmers and University College London, and Philip Wadler’s Orwell, amongst others, began working toward a common functional language. Their work led to the first Haskell report in 1990. Haskell grew around mathematical clarity, but also around a desire to share ideas: a language people could use to communicate, disagree, and build on one another’s work.

While we can understand OOP through the direct observation that something may not be any single instance of it, at any given time— observation that in itself comes from experiences that can be easily verifiable, FP in contrast appears as the realization that a transformation may remain the same even when the entities it acts on differ, a thought that requires a displacement of the observer perhaps. Neither is wrong, as the subjects, adjectives and verbs all can only attempt a reconstruction of phenomena that doesn’t exist within the language inasmuch as it exists inside the computer, but the scaling of computers suddenly allow modeling more and more, to the degree that we find the seams in either model.

Two hand-drawn panels. Left, headed follow the thing: the same circle drawn three times along a dashed line, marked then, later, and now, holding one, two, and then three dots. Right, headed follow the change: a circle, a square, and a triangle each pass through one box labeled f and come out doubled.
Following an entity through time vs. following a transformation.

Models, uncertainty, and shared meaning

For as long as the practice of software engineering has existed, our ability to model the world has been limited not only by resources (compute, headcount, or otherwise), but also by what our minds can hold and communicate at any given time. As we’ve seen, centuries had to pass for us to reconsider even relatively narrow ideas about how things relate to one another. Yet the demand for disambiguation and understanding is only increasing in the era of AI, because what we can represent, generate, and act upon is beginning to far exceed what any one person can reasonably hold.

What might begin as the implementation of a chatbot that answers questions from a corpus, it does not halt at that stage. Soon it becomes a problem of understanding. The level of specificity that worked for us prior to AI mostly worked because we assumed that whatever was lost in our representations could be recovered by people as they became better at their jobs. A document didn’t have to explain everything, because the person reading it could ask someone, remember an earlier conversation, or recognize that an instruction no longer applied. Even if the interpreter has learned to generally understand humans, it still has not learned to become effective within any specific human organization. Anything not thoroughly specified becomes a source of uncertainty, and the problem aggravates if such entity can produce documents and act upon them at a pace no one can reasonably follow.

We might follow each step that brought an answer to us: the search, the prompt, the model’s response. Yet one document might describe a policy that another has implicitly superseded, while a third might refer to an exception that was never formally acknowledged. To understand what happened, we can reason about the parts and experiment with the system, but we must also consider the person asking the question, the human systems around them, and the distinction between what is explicit and accessible within the digital world and what may exist without ever having been digitized.

What appears to be an incomplete specification might, in practice, have been perfectly sufficient for a team of people familiar with that environment. The problem is that the specification was never the whole system. Part of the system existed in the people interpreting it, and the meaning of what was written depended on what they already knew.

To understand these new systems that act upon human language, we increasingly have to examine distributions of behaviors across multiple turns. Soon we encounter population dynamics, incentives more commonly studied in economics, and questions about actions and events under incomplete information.

So, while a support assistant might improve its rate of “resolved” conversations, the underlying failures might have been accidentally obscured. A subtle change might make it harder to reach a human, and conversations that would previously have been escalated are now closed by the assistant. So, some metrics may improve while the service gets worse. On one hand, of course, these are ostensibly new technologies and soon enough we will adapt to them, but on the other hand, have we truly pondered what words such as “resolved” mean? Because inconsistencies on who defined it, what assumptions went into that definition, or what behavior it rewards over time, however subtle the disagreements may be, can now be amplified into problems that may only appear an indiscernible amount of time after the system gets delivered to customers.

A hand-drawn chart over time: a solid line labeled resolved and a dashed line labeled people helped start at the same point; resolved rises while people helped slowly falls, and a bracket marks the gap between them. Below, three doors labeled talk to a person get smaller from left to right.
“Resolved” keeps rising as it becomes harder to reach a person.

Words we use may carry histories and expectations we never truly signed into. A user might be a person in one system and an identity associated with several organizations in another. An account might represent a customer, a billing relationship, or a collection of permissions. Even a successful transaction might mean that a payment was accepted, that an order was fulfilled, or merely that no error was reported. It takes to dive into how they are locally applied to reveal just how much interpretation is taking place.

While Saussure understood linguistic value through differences and relationships within a system of signs, Terrence Deacon’s work on symbolic reference offers another useful perspective: symbols depend not only on their relationships with other symbols, but also on the interpretive processes and learned conventions through which they come to signify something. What we often believe to be settled or obvious may actually be held together by much more fragile webs of people and practices, so when the people change, the meanings can change with them, sometimes irreconcilably.

A wider practice of computer science

How does something remain itself as it changes? What can we learn from its relationships, and from the world around it? The French philosopher Gilbert Simondon offers a way to bring these questions together. Like the structuralists, he paid attention to relationships, and he also asked how they come to be, together with the individual, through the processes and milieu in which it takes form. His 1958 work on technical objects places technics within human culture, among the ways people understand and shape their world.

Perhaps the city, too, is that which keeps taking form.

Three hand-drawn views of the same walled hill town. In the first, part of the wall has fallen into rubble; in the second, a river runs through the town and many small figures cross a bridge in both directions; in the third, a pencil is still drawing new buildings and the outline of the wall.
The city continues being the city, despite the changes.

So far, we have directed much of software engineering toward optimization. Of course it matters that software can be optimized, the way we would want an engine to perform at its best. But much of what we have called best practices is modes and styles of expression, similar to modes in other art forms. Once we reach the most optimal solution, the exercise of discovering how to communicate and share ideas would be over. Even if new technologies displace the tools we have used so far, programming languages as a whole, the art remains in that expression, in the conversation we have held together over decades, perhaps over centuries, about how to represent and work with abstractions in ways that give us tools to reshape the world.

Afterword: Agents and artificial societies

As it turns out, we had been exploring population dynamics through computational models long before modern AI. One of the more consequential periods was the Cold War, when the possibility of nuclear disaster brought renewed attention to game theory and the difficulty of anticipating decisions made under incomplete information. Alongside these developments, computers made it increasingly possible to explore complex interactions through simulations. Much of this analysis concerned the behavior of entire systems, attempting to anticipate how different decisions and circumstances might change their outcomes. But another approach was taking shape, one in which simple rules at a microscopic scale could produce behaviors at a macroscopic scale. Thomas Schelling, for example, explored how relatively modest individual preferences could produce widespread residential segregation, even when no individual sought that outcome. Alongside work in cellular automata, ecology, and computational social science, such experiments contributed to the development of a field now known as agent-based modeling, where researchers could study populations by simulating the interactions of their individual members. In this field, Joshua Epstein and Robert Axtell published Growing Artificial Societies (1996), exploring how local interactions between artificial agents could give rise to patterns of migration, trade, and cultural differentiation. Here we encounter a term that would become central to the study of complex systems: “emergent behavior”. What appeared at the population level wasn’t necessarily something any individual agent had been instructed to produce.

Two hand-drawn grids of filled and hollow dots. On the left the two kinds are mixed, labeled everyone is fine with mixed neighbors. An arrow marked each moves if fewer than a third of its neighbors are alike leads to the right grid, where the same dots have gathered into separate clusters, labeled no one chose this.
In Schelling’s model, a modest preference about neighbors turns into an unexpected pattern.

I find myself wondering about the people who set up these worlds and interpret what happens in them, and about the people who may eventually live with what gets built from those observations. In software engineering, those people are us. Now our tools have become agents, making decisions and increasingly interacting with other systems on our behalf. Many of us now work with them every day, trying to make sense of how everything has changed, and of how to continue the conversation that software engineering always has been.