Personification of computer processes

We can think of computer software as layers upon layers of metaphors built on top of each other to bridge the gap between how computer hardware works and how humans intuit the world.

For instance, the most well-known metaphor is probably the desktop metaphor, which profoundly altered our interactions with computers, setting a new standard of user experience when it was brought to mainstream use with the Apple Macintosh in 1984.

Yet, no metaphor has made the act of programming feel truly intuitive.

In Bret Victor’s talk The Humane Representation of Thought, he points out three modes of understanding as described by Jerome Bruner:

  • Enactive representation (action-based)
  • Iconic representation (image-based)
  • Symbolic representation (language-based)

He says the following at 18:10:

Another useful one was presented by Jerome Bruner, adapted from Piaget’s theories. He talked about action-based, image-based and language-based understanding. Riding a bike is something that you understand by doing it. You can’t talk about how you ride a bike. The understanding lives in a performing of it. Then there is an image based understanding. You look at the drive train of bike and see how the sprocket is pulling the chain over the derailleur, and you understand this complex mechanical system in this image based wordless way. And then, of course, there is language based understanding, understanding you can articulate, you can talk about parts of a bike, you can talk about gear rations and calculate them. I think most of us in this crowd tend to gravitate towards the symbolic, and so I think it’s important to remember that speech is purely symbolic. The most important invention in humanity was the invention of writing. Where you took speech and turned it into an image based iconic second channel form. That’s what happens when you get multiple channels involved it leads to understanding that would not be possible in any single one.

The metaphor I’m about to introduce aims to expand the use of our innate capabilities while we program computers, primarily through action-based, secondary through image-based, and tertiary through symbolic-based representations. It’s an attempt to turn actions performed with our entire bodies into actions that a computer can understand and interpret as computations.

Hello, Being

Meet the being, a metaphor designed to personify computer processes, giving them human-like attributes.

Beings live in a world of digital spaces. They can move around a space and interact with objects in the environment they inhabit. They can also travel between spaces.

These are the most basic capabilities that beings possess, similar to those of humans.

However, certain aspects of these capabilities are unique to beings. For example, beings can move through space at immense speeds, perceived by humans as the speed of light. Their speed is one of the defining characteristic that makes the existence of beings so valuable to humans. While humans could in theory accomplish everything beings can, it might take us a million years, whereas for beings, it takes only a fraction of a second.

The basic idea of a being has many possible manifestations.

One possibility is to imagine a being moving as a character in game-like 3D spaces. Another is to picture it as a 2D character on a 2D plane, akin to a platformer game. A third is to picture a being roaming the landscape of an isometric video game. Lastly, imagine yourself as a being in a physical world.

Each of the above manifestations demands varying levels of creative effort. To bring the metaphor to life within this essay, I’ve created a series of low-fidelity 2D animations. They provide a mere glimpse of the vast possibilities.

As you continue, you will learn more about the capabilities of beings, about the world they inhabit, and, more importantly, how that world relates to human everyday experiences and computing.

First Contact

Observe the above 2D silhouette, standing on two tiny feet, alone in a void. It’s a simple graphical representation of a being.

Try interacting with the being. Select it, then right-click on gray markers to navigate its movement.

You’ve just given the being its first instructions.

The being personifies a computer process capable of catalyzing changes in the space. In turn, the space transforms from static to a computational space due to the actions of the being.

Of course, no meaningful computation can occur in an empty space like in the one above.

Let’s step back and consider the relationship between humans and the universe, to better understand the relationship between the being and the space it inhabits.

Every moment, myriad processes unfold in parallel across the universe. Mountains rise, black holes form, offspring grow in their mothers’ wombs, flowers bloom. The driving force behind these processes is the invisible hand of nature.

Alongside, another set of processes takes place: bridges rise over rivers, cities emerge, art comes to life on canvas, space probes shift their courses. The driving force behind these processes is humans. Humans are the agents of change and in turn become the processes.

The relationship between a being and a space mirrors that between humans and the universe they inhabit.

A being is also an agent of change in a space and in turn becomes the process.

Portals, Parcels, and Spots

Computations within a space can occur only when the space is populated with objects that a being can interact with. Let’s look at an example set of objects that a being can interact with to perform computations.

Every computer programmer is familiar with three fundamental concepts in programming: functions, values, and variables. I’m going to introduce objects with which a being can interact, directly mapping to these concepts.

The meaning of the three concepts varies between programming languages. To ensure we have some shared understanding of what I mean by them, here’s an overview:

  • A function is a block of code that performs some computation. The function definition usually includes the function’s identifier, its parameters, and the body that defines how inputs map to outputs.
  • A value refers to any type of data we process with computers. We apply values as inputs to functions in order to perform computations on them, which in turn return new values as a result of the computation.
  • A variable is a pointer to a function or a value that usually has a human-readable name.

Before we go into the mapping of the above concepts to the objects a being can interact with, let’s observe the being below as it performs its first computation.

Take a guess: How do the three fundamental programming concepts relate to the objects the being interacted with?

In the first step, the being picked up the parcel ☒ from the spot ⬬ on top of which it is placed. Then, the being jumped into the portal ⬯ carrying the parcel and returned with a new parcel. Next, the being placed the new parcel on the second spot.

Mapping a parcel to a value is probably self-evident. Same with mapping a spot to a variable.

However, the mapping of a portal is more nuanced.

A being is not only capable of moving within a space; it can also travel between spaces. Spaces are connected by portals. When a being jumps into a portal, it travels from one space to another.

In the example above, the being goes through the following experiences:

  1. The being picks up a parcel from a spot.
  2. The being jumps into the portal carrying the parcel.
  3. The being travels through the portal to another space that is not visible to us.
  4. The being performs calculations in that space, using the parcel it brought there as an input.
  5. The being jumps back through the same portal, this time carrying a new parcel that represents the result of those calculations.

In traditional programming languages, a function pointer is usually represented by the function’s name. When we invoke a function with some input data, the data appears to flow through the function until we receive the function call’s result.

In the world of a being, a portal represents a pointer to a function, and (usually) a space represents a function.

A portal points to a space, similar to how a function name or some other kind of pointer points to a function itself.

It’s important to note that a space can represent other things as well. It could have a similar role to a file storing code, or an interactive environment similar to an interactive shell. We won’t delve into that just yet.

Below is a short program written in a traditional programming language demonstrating an execution flow that is quite similar to the one the being experienced.

let name = "John"
let length = String.length(name)

If we imagine we are a computer process, what would be the steps we take to execute the program?

  1. The process binds the value “John” to a variable called name.
  2. The process applies the value to a function String.length.
  3. The process changes context to the function definition that is not visible in the code above.
  4. The process follows the computations defined in the function definition using the value as an input.
  5. The process changes back the execution context, binding the result of the function invocation to the variable called length.

If you compare the first sequence of steps the being experiences and the second sequence of steps the computer process goes through, you’ll notice a lot of similarities.

Here is an overview of the mapping of concepts from the world of a being to the concepts we are familiar with in traditional programming languages:

Being → Process; Space → Function definition; Portal → Function name; Parcel → Value; Spot → Variable

I believe the examples above successfully demonstrate that personification of computer processes is viable.

In the space presented earlier, I intentionally visualized only the most basic graphical representations of objects. An observer is left with unanswered questions such as:

  • What values do the parcels hold?
  • What kind of computation occurs when the being jumps into the portal?
  • What happens inside the space that the being visits through the portal?

This omission was intentional, to keep the focus solely on two core questions:

  • How can I relate the world in which the being exists to my own?
  • How can I link the being’s world to programming concepts with which I am already familiar?

The metaphor presented in this essay isn’t about “visualizing code”. The purpose is to use the metaphor to directly program with it.

In the future, we will gradually expand our understanding of the world in which beings live and how they interact with humans.

To be continued…

I believe the personification of computer processes has vast implications for interacting with and programming computers. The metaphor of the being lays the foundation for answering the question of how to design computing that makes us feel alive.

This website is a digital garden, which means it is a continuous work in progress, regularly updated with new research. To stay up to date with the latest findings, you are welcome to subscribe at the bottom of the page. If you wish to discuss or support my research, write to

A Preview of Future Topics

In forthcoming updates, I plan to delve into what the equivalents of the following concepts would be in the world of beings:

  • Defining new functions
  • Defining conditional logic
  • Defining higher-order functions
  • Defining recursion
  • Facilitating communication between computer processes
  • Working with interactive shells
  • Writing applications
  • Writing low-level machine instructions
  • Performing step-by-step debugging
  • And more.

Pages mentioning this page

Navigate Latent Centers

The website is structured as a digital garden. Here are all the pages, along with their links, visualized as a graph.

Personification of computer processes Why "Latent Centers"? Computing that makes us feel alive