Categories
Free Culture Free Software Reviews

The People’s Platform

The People’s Platform” (TPP) is a frustrating read. An anti-techno-utopian critique of the economics and politics of culture on the Internet, it contains much interesting research and some useful ideas but is hamstrung by a year zero activism approach to the history and current state of the struggle for liberty and sustainability in technology and media.

Year zero activism has two planks. Firstly, the situation has never been worse and only now are activists starting to tackle it. Secondly, anyone who may appear to have previously done so is actually part of the problem. Previous activism is at best ineffective and at worst exacerbatory, previous activists were tone deaf to or in reality made worse the very issues they sought to address.

In TPP this leads at times to an almost ‘pataphysical identity of opposites. Google and Wikipedia are both “open”. Chris Anderson and Richard Stallman both use the word “free”. The nadir of this approach comes later in the book when TPP is explaining the economic and thereby cultural harm of free culture and free software:

Cohen is highlighting a value that has long been central to any progressive movement: respect for labor. From this angle it’s clear that “copyleft”, as the free culture position on copyright is sometimes called, is not “left” in the traditional sense. As Richard Stallman told me, he designed copyleft to ensure the freedom of users to redistribute and modify copies of users to redistribute and modify copies of software. Freedom to tinker is the paramount value it promotes, but a left worthy of the name has to balance that concern with the demand for equality, for parity of wealth and power.

There’s no part of this that’s right.

Stallman’s creation of copyleft was a product of the political development of Free Software in reaction to the alienation of the products of hacker labour. It’s an answer to the property question, which is a question of the left “in the traditional sense”. It entails respect for labour, and ensures that workers can charge for and be paid for their labour.

Users who modify and “tinker” with software do so via programming, that is by working as programmers, by performing the labour of software development. Software developers are first of all software users. If you are not free to use software you are certainly not free to develop it. The same is true of cultural production, a point that TPP seems slightly more open to.

“Copyleft” is not a blanket term for free culture approaches to copyright, it is the name of a particular licensing approach that seeks to address the restrictions of copyright. There is no single free culture approach to copyright. There are copyright abolitionists, copyright libertarians, copyright socialists and those, like Stallman, for whom copyright’s ironisation by copyleft is a means to a political end.

Seeking to reduce free software and free culture to a progressive left wing movement rather than retain the nonpartisan approach that has seen their successes (or, as TPP would have it, has led to identity with their proprietary others) would undermine them. It’s classic entryism, finding a successful specific social cause to shame into attempting more general radical politics. It’s an approach that is doomed to failure.

And copyleft is precisely intended to equalise wealth and power in the use of software. You can share that wealth, and you cannot exert power over anyone else to prevent them from doing so as well. What you cannot do without breaking the effectiveness of copyleft, and what each new critic of copyleft is drawn to like a moth to a flame, is to yoke copyleft’s reflexive ironisation of copyright on software or cultural work to extraneous political objectives.

TPP continues:

Copyleft, with its narrow emphasis on software freedom, even when broadened to underscore the freedom of speech implications of such a position, offers a limited political response to entrenched systems of economic privilege, and it does not advance limits on profitability or promote fair compensation. Free culture, with its emphasis on access, does not necessarily lead to a more just social order.

Ignoring the slip from free software to free culture, the slip from social to economic justice, and the inaccurate characterization of free culture as emphasizing access, this is a political erasure. Free software and free culture may not have provided grossly coercive tools to the political left but they have, by TPP’s own explanation of their redistributive and deprivileging effects, led to a more just social order. And it requires precisely the ‘pataphysics of “free” and “open” that TPP develops to argue that they limit compensation but not profit.

Later, TPP calls for the development of more socialised alternatives to Web 2.0’s ad-driven surveillance model, and for the development of more equitable alternatives to unpaid cultural workers trying to live on whuffie while making Silicon Valley CEOS rich. I agree that this is vitally important. I’ve worked on several myself. I’ve seen creators paid, clients satisfied, citizens communicating, audiences enjoying media, with millions of dollars put into the cultural economy and tens of thousands of people engaged each month by projects I’ve been involved in. There is absolutely more work to do, but ignoring existing efforts or worse conflating them with the problems they exist to address will only ensure that this is always the case.

There is another key conclusion of TPP that I agree with wholeheartedly. We need a sustainable ecosystem for culture. That is, we need technological and economic systems that sustainably align consumption and production incentives with each other and with political and creative liberty. And state and corporate mechanisms for spreading risk absolutely have a part to play in this. But as blank media levies and the deep packet inspection consequences of the proposals of “Promises To Keep” show, this is a task that needs approaching with an insight and subtlety that both pro- and anti- free culture activists often lack.

In this sense at least TPP is not year zero, it is business as usual.

Categories
Free Software Projects

ace

ace
ace is a command-line development environment for Ethereum contracts.

It’s designed to simplify writing and testing contracts. The initial (alpha!) version supports Serpent contracts and local testing using pyethereum.

You can get it here:

https://gitorious.org/robmyers/ethereum-ace/

For an Emacs mode for editing Serpent code, see here:

http://OFFLINEZIP.wpsho/2014/05/20/serpent-mode-for-emacs/

Bug reports gratefully received.

Categories
Free Software Projects

serpent-mode for Emacs

serpent-mode

serpent-mode is a GNU Emacs major mode for editing and compiling Serpent code.

Serpent is a Python-inspired language for writing smart contracts that compile to Ethereum Virtual Machine bytecode. It adds syntax highlighting and indentation for Serpent code, and allows files to be compiled from within Emacs.

You can get the serpent-mode here:

https://gitorious.org/robmyers/serpent-mode/

https://github.com/robmyers/serpent-mode

Some of the indentation code has been borrowed from Emacs’ built-in Python mode but any deficiencies are a result of my simplifying it to work with Serpent. Reports of errors and omissions gratefully received.

Categories
Free Software

Ethereum Contract Free Software Licensing

Here’s a simple example of a contract that is licensed under the GNU Affero General Public License:

LICENSE = ["Copyright 2014 Rob Myers", "Licensed GNU AGPL V3+"]
SOURCE = ["https:\/\/gitorious.org\/robmyers\/", "artworld-ethereum/"]

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 100:
    // If not, stop
    stop

if msg.data[0] == "license":
   return(LICENSE, 2)
else if msg.data[0] == "source":
   return(SOURCE, 2)
else:
    // Return false
    return(0)

Assuming that being part of the blockchain doesn’t clash with the AGPL. Anyone? 🙂

Categories
Art Art Computing Culture

Cryptocurrency Culture

http://thecypherfunks.com/

“”The Cypherfunks” is a network of musicians working individually & together to make music under the same name. A cryptocurrency [FUNK] acts as “stock” in the band.

Both the currency & band are completely decentralized. It is a grand experiment in permission-less, internet scale innovation in music, collaboration, and technology.”

http://www.monegraph.com/

http://techcrunch.com/2014/05/09/monegraph/

“monegraph helps anyone verify that a digital artwork is an original, exactly as created by the artist.

monegraph encourages a vibrant market around the sale and exchange of digital art.

monegraph uses the same technology as Bitcoin to let anyone participate in the digital art market.”

https://forum.ethereum.org/discussion/446/the-ephemeral-artcoin

The Ephemeral Artcoin (EA) is a platform designed to spark the creation of qualitative new works of non-commercial art in the post-bitcoin digital economy.

http://bitcoinmagazine.com/12259/fine-art-meets-bitcoin-rise-aesthetic-paper-wallet/

“Fine art meets bitcoin cold storage in Troy Fearow’s “labour of love”, CryptoArt, a project that took the fine art dealer 8 months to construct and launch.

Troy searches for and commissions high level artists, starting with Alexander Fedosov of the Ukraine, to produce fine art paper wallets in limited editions. These prints are meant for bitcoiners who wish to store their bitcoin safely and show them off in a beautiful way.”

http://saycheers.co/

“Cheers is an app that allows you to tip (or “Cheer”) any musician or band in the world using Bitcoin. You can Cheer any song or band, whether it’s your all-time favorite, or just a song that you loved on the radio that you’ve never heard before. See what your friends are Cheering, discover new music and reward them for finding it.”

Categories
Art Art Computing Howto Projects

Artworld Ethereum – Identity, Ownership and Authenticity

Ethereum is a distributed computing system for writing and executing smart contracts. Inspired by Bitcoin, it’s currently in development with a planned late 2014 release date. The term “smart contracts” was coined around 1993 by computer scientist Nick Szabo to describe computer-readable code that replaces lawyer-readable code to describe agreements and obligations between people.

It’s a very literal take on Lawrence Lessig’s argument that “code is law”, a libertarian attempt to reduce the costs and uncertainty of having to trust human beings and interpret ambiguous human language, or possibly a dystopian replacement of rights and safeguards with binary logic.

Smart contracts can be used to implement smart property, physical goods governed by computer code, and Distributed Autonomous Organizations, which replace written constitutions with code running on Ethereum’s Blockchain.

This series of articles will look at applications of Ethereum to the production, exhibition, critique and institutions of art. Starting with digital art as smart property.

The sample code is written in Serpent, the high level Ethereum programming language, and is current as of Ethereum POC 5. It will be revised and tested for the release version of Ethereum.

You can learn more about Ethereum here and here. You can learn more about Serpent here and here.

Storing and Identifying Digital Art In Ethereum

There are three cases of digital art as smart property. The first is the conceptual or code art case, where the code of the contract itself is or contains the artwork. The second is the Ethereum storage case, where a small digital artwork is stored in the Ethereum datastore. The third is the stored identifier case, where only an identifier or proxy for the artwork is stored with the contract.

Conceptual and Code Art

Contracts that are themselves art are a simple case. They should store their owner’s Ethereum address and ensure that transactions initiating actions that only the owner should be able to perform come from that address.

Conceptual Art

As art is defined by its inutility, a contract that does nothing must be art. 😉

stop

Hot/Cold

A contract that does something, but nothing useful.

init:
    contract.storage[1000] = "hot"
    contract.storage[1001] = "cold"

code:
    // Make sure we have enough gas to run the contact
    if tx.value < tx.basefee * 100:
        // If not, stop
        stop

    // Swap
    temp = contract.storage[1000]
    contract.storage[1000] = contract.storage[1001]
    contract.storage[1001] = temp

Numbered Works

A simple generative work that creates a new, original piece for each request.

init:
    ARTWORK.NUMBER.INDEX = 1001 
    contract.storage[ARTWORK.NUMBER.INDEX] = 1

code:
    ARTWORK = "Work #"
    ARTWORK.NUMBER.INDEX = 1001
    // Make sure we have enough gas to run the contact
    if tx.value < tx.basefee * 400:
        // If not, stop
        stop

    // Get the number of the work to produce
    number = contract.storage[ARTWORK.NUMBER.INDEX]
    // Store the number to use for the next work
    contract.storage[ARTWORK.NUMBER.INDEX] = contract.storage[ARTWORK.NUMBER.INDEX] + 1
    // Return the work
    return([ARTWORK, number], 2)

Data Visualization

A simple customised generative work / data visualization. The output looks something like:

when assembled.

HEX = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]
ARTWORK = [""]
ARTWORK.LENGTH = 10
ARTWORK.INSERT.END = 8

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 500:
    // If not, stop
    stop

// If there are enough arguments
// and the command to create the work is being given
if msg.datasize == 1 and msg.data[0] == "create":
    artwork = array(ARTWORK.LENGTH)
    artwork[0] = ARTWORK[0]
    artwork[1] = ARTWORK[1]
    artwork[2] = ARTWORK[2]
    artwork[9] = ARTWORK[3]
    // Copy the most significant hex bytes of the key as an html colour
    index = 0
    hash.bytes = msg.sender
    while index < 3:
        current.byte = hash.bytes % 256
        hash.bytes = hash.bytes / 256
        hi = HEX[current.byte / 16]
        lo = HEX[current.byte % 16]
        artwork[ARTWORK.INSERT.END - (index * 2)] = lo
        artwork[ARTWORK.INSERT.END - (index * 2) + 1] = hi
        index = index + 1
    return(artwork, ARTWORK.LENGTH)
// Otherwise
else:
    // Logical false for failure
    return(0)

Stored Art

Digital art can be stored in a contract’s bytecodes or permanent storage rather than generated by the contract’s code.

A Stored Image

ARTWORK = ['P1\n32 32\n00000000000000010000000', '00000000000000000000000010000000', '000000000000000\n0000000001000000', '00000000000000000000000001000000', '0000000000000000000000\n001100000', '00000000000000000000001100001010', '00001100001000000000100000000\n00', '01011000010000000000100000000000', '01111000100000000001000000000001', '1111\n000100000000001000000000011', '11110110000000000010000000001111', '11100010000\n00000000000000011111', '11000000000000000010000001111111', '110000001000000000\n1000001111111', '11000000000000000000000000111111', '1110000001000000000000000\n000011', '11111000000000000000100000000001', '11111100000100000000000000000111', '\n1111110000000000000010000000011', '11111100000100000000010000001111', '1111000\n000010000000000000000111', '11110000000000000000000100001111', '10000000000100\n00000000000001111', '10000000000010000000000001111100', '000000000001000000000\n0000011100', '00000000000100000000000000101000', '0000000000000000000000000000\n010', '10000000010100000000000000000000', '01010010100000000000000000000000', '000\n0110000000000000000000000000', '00000100000000000000000000000000', '0000010000\n000000000000000000000', '00000010000000000000000']

ARTWORK.LENGTH = 33

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 1000:
    // If not, stop
    stop

// If there are enough arguments
// and the command to show the work is being given
if msg.datasize == 1 and msg.data[0] == "exhibit":
    // Just return the artwork
    return(ARTWORK, ARTWORK.LENGTH)
// Otherwise
else:
    // Logical false for failure
    return(0)

Identifiers For Digital Art

Where a work of digital art will not fit in the blockchain a more compact identifier must be stored in the contract and used to refer to the work instead.

Ideally a method for identifying unique instances of a digital artwork will be:

  • Stable. The identifier should be usable for decades. Web URLs for example can change or become inaccessible as services change how they serve content or go out of business.
  • Verifiable. The identifier should be usable as a way of verifying that a resource is the one it refers to. Cryptographic hashes for example will not work with digital images that have been resized or GPS co-ordinates that differ even fractionally.
  • Amendable. Where stability fails or a change in ownership requires a change in identifier, it should be possible to update the identifier in a trusted and verifiable way.
  • Sufficient. The information required to identify the resource should be usable directly from the contract rather than requiring external information to complete it.
  • Private. An identifier should leak as little information about the owner of the resource as possible. For example GPS co-ordinates or street addresses, while stable, do locate the resource and possibly its owner. Storing only the cryptographic hash of an identifier can mitigate this.

Some of these criteria clash and therefore any given method of identification must trade them off against each other. For example being private and verifiable, or stable and amendable.

For artworks to interact with smart contracts we need a way of identifying them in those contracts.Where a digital artwork is too large or complex to keep in the contract’s code or storage, a proxy or compact identifier that refers to the must be used.

The following identifiers have various strengths and weaknesses. We’ll use some of them in the next section.

URL

A URL, such as a web site address, is a clear public identifier. It lacks privacy and is only as stable as the service hosting it, but has the advantage of being unique. To add a veneer of privacy, only the cryptographic hash of the URL can be stored by the contract and this can be checked against the hash of a URL by anyone who wishes to check whether it is the instance of the work referred to by the contract.

For example the url:

http://OFFLINEZIP.wpsho/wp-content/uploads/2012/10/applied_aesthetics-824×1024.png

has the SHA256 hash:

6a1811d79b46ab9e43f449beb9838e21dc5865d293e3dfb9b4ba508c7261b915

Never use a link shortening service or a consumer third party hosting service for work represented as URLs, such services are likely to go out of business or change their URL structure, rendering identifiers using them useless. When using your own site for hosting work make sure both to both keep your domain name registered and the server running and to make provisions for them to be maintained when you are no longer able or willing to do so.

File Hash

Producing a cryptographic hash of a work contained in or represented by a file is simple and uniquely identifies the data contained by the file (although any copies of the file will have the same hash). It is better to hash the contents of the file rather than the file itself: an image that has the same pixel values as a PNG or a GIF will have a very different structure on disk in each of those formats. Likewise the full-size or full-quality version of the contents of the file should be hashed rather than a thumbnail or a lossy version.

Git Repository Commit Hash

Modern decentralised version control systems use cryptographic hashes to identify commits. Hashes can identify version of works in a series within a version control repository, although they are best accompanied by a URL or other identifier for the repository.

Serial Number or UUID

A serial number or unique identifier embedded in the work’s filename or metadata can be used to identify it. Visible watermarks are the mark of the amateur, and steganographic watermarks are easily defeated.

Cryptographic Signing

When producing editions of a digital work, each can be signed by the artist to identify it as authorised.

Name

When all else fails, a unique name and description for a work is a useful identifier.

Art As Smart Propery

A Simple Owned Work

OWNER = 0x7c8999dc9a822c1f0df42023113edb4fdd543266

// Get the owner Ethereum address
return(OWNER)

A Simple Owned Work That Confirms Ownership

OWNER = 0x7c8999dc9a822c1f0df42023113edb4fdd543266

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 100:
    // If not, stop
    stop

// If the Ethereum address sent matches the owner
if msg.data[0] == OWNER:
    // Return true
    return(1)
// Otherwise
else:
    // Return false
    return(0)

A Simple Owned Stored Work

OWNER = 0x8802b7f0bfa5e9f5825f2fc708e1ad00d2c2b5d6 // Artist initially
WORK = "The art happens here."

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 200:
    // If not, stop
    stop

// If there are enough arguments
// and the command to return the owner address is given
if msg.datasize == 1 and msg.data[0] == "owner":
    // Return the owning Ethereum address
    return(OWNER)
// If there are enough arguments
// and the command to return the artwork is given
if msg.datasize == 1 and msg.data[0] == "work":
    // Return the work
    return(WORK)
// Otherwise
else:
    // Return logical failure
    return(0)

Simple Transferable Stored Work

init:
    ARTIST = 0x8802b7f0bfa5e9f5825f2fc708e1ad00d2c2b5d6
    OWNER = 1001
    // Initialize the owner to be the artist
    contract.storage[OWNER] = ARTIST
code:
    OWNER = 1001
    ARTWORK = "The art happens here."
    // Make sure we have enough gas to run the contact
    if tx.value < tx.basefee * 200:
        // If not, stop
        stop

    // If the message is from the current owner
    // and there are enough arguments
    // and the command to transfer is being given
    if msg.sender == contract.storage[OWNER] and msg.datasize == 2 and msg.data[0] == "transfer":
        // Transfer it to a new owner
        contract.storage[OWNER] = msg.data[1]
        return(1)
    // If there are enough arguments
    // and the command to show the work is being given
    else if (msg.datasize == 1):
        // Just return the artwork
        return(ARTWORK)
    // Otherwise
    else:
        // Logical false for failure
        return(0)

An Ownership Registry For Digital Art

if tx.value < tx.basefee * 200:     // If not enough gas, stop     stop // If data was provided, it won't overwrite the code, and the artwork is unregistered if msg.datasize == 1 and msg.data[0] > 1000 and contract.storage[msg.data[0]] == 0:
    // Set the owner to be the sender
    contract.storage[msg.data[0]] = msg.sender
    return(1)
else:
    // Do nothing
    return(0)

A Hash-based Ownership Registry For Specific Instances Digital Art

This is a registry for ownership of artworks at specific urls. Artworks are identified by the hash of their file contents and by the hash of their url. Owners are identified by Ethereum address.

if tx.value < tx.basefee * 200:
    // If not, stop
    stop

// If registration is being requested
if msg.datasize == 3 and msg.data[0] == "register":
    // If the url/work combination has not been claimed
    if ! contract.storage[msg.data[1]]:
        // Set the owner to be the provided Ethereum address
        contract.storage[msg.data[1]] = msg.sender
        // Store the artwork hash next to the url ownership information
        contract.storage[msg.data[1] + 1] = msg.data[2]
        // return success
        return(1)
    // If the sender was trying to overwrite a work they do not own
    else:
        // They cannot set it, so return failure
        return(0)
// If ownership confirmation is being requested
// Confirm that the work and url hashes match
else if msg.datasize == 4 and msg.data[0] == "confirm":
    // Check the provided hashes against the stored work and url hashes
    return((contract.storage[msg.data[2]] == msg.data[1]) and (contract.storage[msg.data[2] + 1] == msg.data[3]))
// If no action was specified
else:
    // Otherwise do nothing
    return(0)

Authenticating Art In Ethereum

Authentication, like ownership, is related to identity and contract law.

A Simple Certificate Of Authenticity For Digital Art

ARTIST = 0x8802b7f0bfa5e9f5825f2fc708e1ad00d2c2b5d6
ARTWORK.HASH = 0x76bba376ea574e63ab357b2374d1cee5aa77d24db38115e3824c5cc4f443d5f7

return((msg.data[0] == ARTIST) and (msg.data[1] == ARTWORK.HASH))
ARTIST = 0x8802b7f0bfa5e9f5825f2fc708e1ad00d2c2b5d6
WORK.HASH = 0x76bba376ea574e63ab357b2374d1cee5aa77d24db38115e3824c5cc4f443d5f7
URL.HASH = 0xa005b1625af0b6ee080dafb904c4505ad285764071ee45a8786159bd1a282634

// If there are enough arguments
if msg.datasize == 2:
    // Check the provided hashes against the stored work and url hashes
    return((msg.data[0] == WORK.HASH) and (msg.data[1] == URL.HASH))
// Otherwise
else:
    // Do nothing
    stop

Catalogue Raisonné For Digital Artists

ARTIST = 0x8802b7f0bfa5e9f5825f2fc708e1ad00d2c2b5d6

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 200:
    // If not, stop
    stop
    
// If the message is from the artist
if msg.datasize == 1 and msg.sender == ARTIST:
    // Add the work to the catalog
    contract.storage[msg.data[0]] = 1
    return(1)
// check inclusion
else if msg.datasize == 1:
    // Check whether the artwork is in the catalog
    return(contract.storage[msg.data[0]])
// Otherwise
else:
    return(0)
Categories
Art Art Computing Free Culture Generative Art Projects Satire

Monkeycoin

monkeycoin

Monkeycoin is the follow-up to Facecoin. It is a Bitcoin-like cryptocurrency that uses trying to write the complete works of Shakespeare as its proof of work. You can find out more here.

Categories
Art Art Computing Projects

Pome

pome "(Poets Are|Poet Is)"
pome "Poets? Must"
pome "(Poems Are|Poem Is)"
pome "Poetry Is"
pome "Best Poetry"
pome "Good Poetry"
pome "Bad Poetry"
pome "Worst Poetry"

I have a piece of work in the latest issue of Truck, curated by Alan Sondheim:

http://halvard-johnson.blogspot.com/2014_04_01_archive.html

It’s a Bash script called Pome, you can read it and its output here:

http://halvard-johnson.blogspot.ca/2014/04/rob-myers-binbash-cat-pome.html

The script downloads the text of the Project Gutenberg CD and searches for mentions of poetry and related concepts, gathering together assertions about them. Originally I started using Python, but Bash ended up being easier to use. It serves as a demonstration of the strengths and weaknesses of Digital Humanities approaches to text and to fear of them.

I like the output, particularly the last piece.