Lottery Symbol

“Lottery Symbol”,2017, DApp.

A graphical symbol on the blockchain, chosen via a simple lottery (using the blockchain itself as a source of entropy).

This is a piece in a series of works that pair methods of allocation with aesthetic properties. It follows on from Democratic Palette.

You can access it via an Ethereum-enabled browser here and the source code is available in a git repository here.

Using The Palette

palette-chooser

The “Democratic Palette” contract provides 12 colours to use. What happens if griefers set the palette to 12 colours that are almost exactly the same? What happens if you need colours with more or less contrast or hue difference? What if you need more or fewer colours? The only guarantee about them is that they will all be different by at least one point.

To fetch the current palette:

var withPalette = function (callback) {
  var democratic_palette = Democratic_palette.deployed();
  var requests = [];
  for (var i = 0; i < 12; i++) { requests.push(democratic_palette.palette(i) .then(function(colour) { return {index: i, colour: colour}; }); } Promise.all(requests).then(colours => {
      var palette = [];
      colours.foreach(function(colour) {
        palette[colour.index] = colour.colour;
      });
      callback(palette);
    });
  }
};

We can then get from one to twelve colours simply by truncating the array, e.g.:

var my_3_colours = palette.slice(0, 3);

Or we can get the bluest colour using a simple comparison:

var bluest_colour = palette.sort(function(a, b){
  return a.blue - b.blue;
})[0];

Or we can take the average of the colours, which will probably represent the triumph of statistics over aesthetics.

More complex orderings and comparisons can be achieved using a colour library that allows us to work in HSV space. In particular we can use a version of the algorithm that Harold Cohen used for one version of his program AARON’s colouring system (see figure 15 here), effectively ordering the colours in the palette by brightness then distributing them evenly across a brightness range sufficient to ensure that each is distinct from its neighbours.

What about more colours, or more structured relationships between colours where we are concerned that those relationships may not be present in the colours voted for within the palette? In the first case we can interpolate between existing colours, producing colours in-between those in the palette. Or in both cases we can use colour theory to produce related colours: complements, split-complements, tints and tones, etc. There are libraries to do this in Javascript, for example color-scheme-js will produce entire colour schemes from individual colours.

“Democratic Palette” is intended to provide the equivalent of an aesthetic or colour symbology backed by Blockchain democracy rather than any other ideology or iconography, so it is intended to be easy and significant to us it as-is. But it’s also possible to maintain a direct relationship to the palette while using colours that are not themselves present within it.

Democratic Palette

palette-spots

Democratic Palette, 2016, Ethereum Contract and HTML/JavaScript/CSS.

A palette of twelve colours that anyone can set on the Ethereum blockchain. Every vote for every colour is tracked and the top twelve make up the palette.

palette-vote

palette-representations

palette-squares

palette-stripes

The images above show various different visual applications of the palette and the use of the GUI to vote for a colour (the GUI appears if you click in the window displaying the canvas).

Note that the above images are from test runs. The current palette on the live Ethereum blockchain looks like this, ready for people to vote on:

live-palette

You can download the interface code here, it’s in the dapps/democratic-palette directory.

To use it you’ll need an Ethereum node running locally, and to vote for colours you’ll need some Ether.

Rationally Irrational Aesthetics

By Headlessplatter at English Wikipedia - Transferred from en.wikipedia to Commons by Shashenka using CommonsHelper., Public Domain, https://commons.wikimedia.org/w/index.php?curid=19346512
Local Maximum by Headsplatter, Public Domain.

Rational aesthetics are an infinite improvement on vapid, asset-class aesthetics but (and this is identifying an opportunity, not an objection) Gödel. If we cast art’s reason as AI-style search (not to fundamentally describe it as such, but to make a hopefully useful comparison) then we encounter the problem of “local maxima“. This is where a direct search of a problem space finds only the closest highest value, not the globally highest one.

In human creativity we can rationally use irrationality to break free of local maxima. Whether creativity theory,surrealist techniques, or pure randomness. Beyond the details of any one technique, what is important is that to get further, we sometimes need to use irrationality (or arationality) for rational ends.

Mythology can be such a source of transformations (in the mathematical sense – we’re talking about search spaces here). Freed of the affective and significatory limits of fact, mythology can lead us to places and to lengths that we might not otherwise reach. This includes science fiction.

In guiding and constructing  new possibilities (or at least finally addressing old problems) through aesthetics, mythology becomes hyperstition (in a general rather than numogram-centred sense). Where we (for a social media value of “we”) believe it is not possible or practical to change anything (for the better), it is rational to construct hyperstitional entities to treat the local maxima of ideology as damage and route around them.

This is haunted by the Big Lie and The Republic, but we do not need to deceive or believe for non- (and a-) existent entities to be historical causes. Just ask Cthulhu. Or Katak. Hyperstitional engineering is accelerationist aesthetics, artistic reason, because of its irrational content not despite it.

The Fractality Of Discourse

Texts exist in discursive space

They contain other texts as quotations and references, self-similar scaled copies.

Major texts are attractors in this space.

Some are singularities that neither light nor heat can escape.

Others are strange attractors that draw endless asymptotic vacillation.

It’s the fractality of discourse.

(After the 1992 original.)

The Entropy Man

DSC_0262

D16 Hex Dice by Saharasav licensed Creative Commons Attribution-Share Alike 4.0 International.

The Dice Man” by Luke Rhinehart is a 1971 novel about the moral consequences of making life-altering decisions using the roll of a die. The use of chance operations in art was common in mid-20th-Century avant-gardes but, reacting against his background in psychiatry, Rhinehart applied them to more consequential decision making.

We can use cryptographic hashes rather than dice as the source of entropy for aleatory, chance operations in art and decision making. The last hexadecimal digit (or digits, for wider ranges of values) can be quantized to the range of values we need: e.g. for a coin flip 0-7 is tails and 8-F is heads.

Private hashes can be the sha256 of a question, statement, or range of options. Or of entropy pulled from /dev/random or a hardware source. Combine these two approaches or use a timestamp to make answers specific to the occasion or time at which they are asked.

Public hashes can be Bitcoin’s block hashes, or the hash of a Bitcoin transaction. The transaction can be time locked or contain the question (etc.) encoded as a has to delay and/or allow proof or disclosure of its content.

Or we can use any of these methods as the decision making basis for computer based or handmade generative art, replacing software pseudo-random number generators with entropy deterministically derived from the existing content of the work or from external sources of “inspiration”.

It’s much more contemporary than a dice, although dice do make good sources of artisanal entropy.

Art For Algorithms

art-for-algorithms

My first article for Furtherfield as guest editor is now online:

Rob Myers takes a look at how we can subvert the operation of the algorithms that the Digital Humanities, corporations and governments use to read, see, and draw conclusions about human expression by treating them as the true audience for contemporary art and literature.

http://furtherfield.org/features/articles/art-algorithms

Critical Coins

dogeart
(Illustration from: http://ofdoge.wordpress.com/2013/12/05/art-doge/, copyright the artist.)

To make the process of art reviews and criticism more transparent and quantifiable, we can use cryptographic asset tokens to represent critical opinion and valences.

See here for how:

http://robmyers.wpengine.com/critical-coins/

Dogecode

dcrun -u rpcuser -w rpcpassword DCvDS9g9VUZ94MSLbWi4zWRtxHrXeEctZ3
Hello World!

Cryptographic asset tokens can represent all kinds of things.

Including computer programs. Introducing…:

Dogecode

(There are several other projects called Dogecode. This isn’t them).

Dogecode takes computer programs in the Brainfuck programming language (chosen for simplicity of encoding):

++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.

and translates them into a csv file of token amounts using dcc:

INCB,8
JFOR,1
INCP,1
INCB,4
JFOR,1
INCP,1
INCB,2
INCP,1
INCB,3
INCP,1
...

which are then sent to a Dogeparty address (slowly) as a series of token transfer transactions using dcsend:

Sending lots of tokens. Make sure you really want to do this.
Waiting for token state to synch
Row 1: INCB,8
Waiting for token state to synch...........
Row 2: JFOR,1
Waiting for token state to synch.............
Row 3: INCP,1
Waiting for token state to synch........
Row 4: INCB,4
Waiting for token state to synch..................
Row 5: JFOR,1
Waiting for token state to synch.......................
Row 6: INCP,1
Waiting for token state to synch.......................
Row 7: INCB,2
Waiting for token state to synch......
Row 8: INCP,1
Waiting for token state to synch......
Row 9: INCB,3
Waiting for token state to synch......
Row 10: INCP,1
Waiting for token state to synch.....................
Row 11: INCB,3
Waiting for token state to synch..............
Row 12: INCP,1
Waiting for token state to synch.....

The transactions encode the program on the address, which can then be fetched and run as seen at the top of this post using dcrun.

For more details see the whitepaper.

Update: There’s an easier to use runner and more examples here.

Blockchain Aesthetics

squares

These images are examples of real-time generative patterns visualising Bitcoin transactions. I wrote them in html5 using blockchain.info’s WebSockets API to get notifications of the hash value of each new transaction.

You can click on each image to open a new window actually running that visualization.

Above, each row is a transaction with each byte of 32-byte hash rendered as a square of colour from a 256-colour palette.

words

Above, each sentence is a transaction rendered in a standard list of words.

bitmaps

Above, each bitmap is the 32-byte hash for each transaction hash rendered as a 16×16 1-bit bitmap (original Macintosh-style, 1 is black).

transactions-spots

Above, each row is a transaction with each byte of 32-byte hash rendered as a spot of colour from a 256-colour palette.

drawings

Above, each transaction is rendered as a drawing of lines connecting x,y co-ordinate pairs taken from the low and high 4 bits in each 8-bit byte in the 32-byte transaction hash. Each transaction is joined to the next as part of the same continuous drawing.

faces

Above, each bitmap is rendered as before and then blurred. A face recognition algorithm is used to find any collections of pixels that accidentally resemble faces, and these are outlined in red. This is machine pareidolia.

As well as clicking on the images to run each visualisation, you can view a list of them here (including both the block and transaction-based visualisations – the former run much slower):

http://show.robmyers.wpengine.com/blockchain-aesthetics/bitcoin-html5/

You can get the code here:

https://gitorious.org/robmyers/blockchain-aesthetics/

https://github.com/robmyers/blockchain-aesthetics/