In the old days, the painting process was often unrefined Cennino Cennini’s Il libro dell’arte is an example of accumulation of techniques aiming at specific subjects’ depiction. Those processes have progressively been abstracted and some some elements of science, such as its understanding of light, have been assimilated.

To the point that nowadays, we can take a shortcut and talk about an axiomatisation of the painting process: there are small sets of rules, axioms, that can be combined at will to help create a wide variety of artwork. This is even closer to be true for digital art.

A shape based painting process

This “axiomatisation” can vary from author to author, but generally involves representing a picture as a collection of shapes of a given color that for the sake of clarity we will define in in terms of HSV: hue, saturation and value. Those shapes connected by a variety of edges, that can be more or less sharp.

Note: This is a “gross”, practical pixelization, through variable-size “pixels”. A key aspect for a painter is to find a few shapes that can encode a lot of (visual) information, while designing such shapes to be rhythmically harmonious. This is blatant for landscape “value” (monochromatic) studies.

Note: The selection of a limited palette, that is, restricting the amount of colors we can express, can help us achieve a certain mood and uniformity. We can already see it in the previous landscapes thumbnails. In the programming realm, we find similar limitations here and there, such as NASA’s The Power of 10: Rules for Developing Safety-Critical Code.

Such shapes are also visible for painters who relied on strongly delineated brushstrokes, such as Leyendecker, Sargent or Zorn.

Marco Bucci emphasizes here the importance of shapes from a design, readability point of view:

Here’s how Richard Schmid uses deductive reasoning to develop a process painting, to identify and to fix errors using a similar shape-based system:

Joshua Been, aka. the Prolific Painter has perfected a similar approach:

He exposes in his book, available for free online, in the Visual Language section:

Axioms, Turing machine

Given the versatility of modern computer usage, it may seem a bit surprising to learn that ultimately, a computer cannot do literally anything: ultimately, to simplify, it’s limited to doing arithmetic, and this is an insurmountable limitation: it’s rooted in the mathematical foundation of computer science.

A great deal of mathematics has been axiomatized: in essence, the idea is that a subdomain of mathematics such as geometry, can be characterized by a small set of simple rules, that one can combine to derive all kinds of more sophisticated results, like Thales’ theorem, Pythagora’s theorem, etc.

We can think of such rules as small lego pieces that can be combined over and over to represent a rather pixelated version of a subset of reality.

As far as computers are concerned, their behavior is, as previously mentioned, ultimately limited by a set of rules, a kind of restricted axiomatic system allowing to express what are called computable functions. There are many such systems, some of them being equivalents: grossly speaking, some models can express the same concepts, only in different ways.

Like a set of blue Lego pieces and the same set with red pieces both have the same expressivity potential, only the color of the constructions will change.

One of the most common models is the Turing machine. It mostly consists of:

• a (theoretically) infinite tape containing cells where one can read/write symbols;
• a finite sets of instruction such as: if we read a “0” while being in the state “reading a number”, move the head one cell to the right, and stay in the state “reading a number”.

A key aspect to understand is that computer scientists use lots of conventions, layer upon layers of arbitrary rules, to increase the usability of such abstract tools for humans.

For instance, the characters you’re currently reading don’t look like numbers to you, but to your computer they are: nearly everything your computer handle ultimately is encoded as numbers, most often in base two: zeroes and ones. Each of those video is one gargantuan number: programmers taught computers the conventions to use to make sense of this otherwise chaotic stream of digits. And those very conventions are also encoded as numbers, and programmers taught computers how to interpret those conventions out of more primitive conventions, and so forth, until we reach the most primitive conventions, which, for the sake of simplification, are close to what a Turing machine can achieve.

A rather impressive, more sophisticated version of a Lego-based Turing Machine: the RUBENS project, by students of the ENS Lyon, France:

Some more theoretical explanations, for those who prefer a less written approach:

Comments

By email, at mathieu.bivert chez: