System, Metasystem, Taxonomy

A system is set of interrelated things that together form a greater whole. A metasystem is a system “about” another system in the sense of describing or controlling that other system. A taxonomy is a system for classifying things into categories. Almost any computing system usually has both a system, the stuff happening inside it, and a metasystem, the stuff controlling it. And we can taxonomize them.

An example of a system is the function abstraction of a programming language. An example of a metasystem is the type system that describes and constrains those functions. Another example would be hosts on a network as parts of a system, and firewall rules or access policies as parts of a (relative) metasystem. System, metasystem, metametasystem. Just like an infinite hierarchy of type universes, systems can be infinitely composed into yet more systems.

To understand and build systems, it helps to consider the roles of different data in those systems. For things to compute, you need functions (system). Functions are described by some algebra (metasystem) that defines what you get when you put things together. That algebra, being a set of rules, can be defined by functions in the metasystem, which we might also call policies. While some entities have dynamic roles (performing operations) others are more static (being operated upon), and this is often what people mean when they compare functions (dynamic) to data (static).

On the dimensions of static vs. dynamic and system vs. metasystem, we can build up a taxonomy:

• Messages are static data in the system that are sent around to be transformed by functions.
  • Through Church encoding, messages may even be made out of functions.
• Functions are dynamic entities in the system that perform transformations. They are machines.
  • Functions are defined in messages.
• Metadata are static data in the metasystem that annotate messages and functions.
  • Metadata are just messages that refer to other entities.
• Policies control message content, including the messages that define the functions, and the composition of functions with messages and each-other..
  • Policies are executed by functions. Policies are defined in metadata.

These pieces are all interrelated and build on each-other. It reminds me of one of my favorite concepts, tensegrity.

Here it is as a table:

This idea is not merely two-leveled, it’s a categorization based on the perspective of a given observer. Real systems add many columns and rows to this table, with connections reaching through the layers in both directions.

To see the self-similarity, it’s sometimes useful to think of these as shapes that grow out of nothing. Nothing is unstable, because nothing is something. As soon as you describe nothing, you have described at least one point. The point is functions. It may in fact need to be functions, instead of data, because to get from data to functions you need a way to describe relationships, and relationships are functions.

If the point is functions, you have data through Church encoding. Static vs. dynamic is defined by relative position, the transformer vs. the transformed (aside: add side-effects, and it’s mutual). Now you have a line. Functions at one end, data at the other.

Or, alternatively, policies and functions. The controller and the controlled. Also a line.

The next point split gives you a triangle. There are four paths to the triangle, two from data/functions, two from policies/functions.

The next after that gives you the square and cross simultaneously, because the first triangle’s relationships are maintained across the split.

Are these ideas circular? Perhaps that’s the nature of it. Space can be cyclic, as long as things come together in time.

March 1, 2026