D A V I D P O C K N E E

Coding: Software

Dodecafinder (2017)

https://github.com/dpocknee/dodecafinder

ruby

A piece of software that uses a genetic algorithm to find optimal 12-tone rows, given a set of criteria.

Twelve-tone composition was a way of composing music that emerged in Germany at the beginning of the Twentieth Century. At its base was a set of techniques based around the idea of a *Twelve-tone row*. A Twelve-tone row is simply a series containing all 12 pitches within an octave, arranged such that each one occurs only once. There are 479 million possible 12-tone rows (12! = 479,001,600). This makes doing a brute-force search for a row with specific characteristics time-consuming and computationally expensive. Dodecafinder uses a genetic algorithmic approach to reduce the time and computation needed to find rows which optimally match a given set of characteristics.

The software is distributed as both standalone windows .exe file, and as ruby source code.

Full code and documentation: https://github.com/dpocknee/dodecafinder

historical-permutations (2019)

https://www.npmjs.com/package/historical-permutations

javascript

A JavaScript library of historical permutation algorithms from 1956 to the present day. I originally started collecting these algorithms together as I was doing some research on early permutation algorithms as part of an ongoing project about the "Permutation Poems" of the poet and artist Brion Gysin. However, I soon found that many of these algorithms were in hard-to-find papers and little documented, often because they were superseded by more efficient algorithms only years later.

I thought that this library might be of interest to those looking to learn about permutations or the history of early computing - especially those who are trying to find out more about the technology used to write early computational poetry. Due to the focus of my own research, nearly all of these algorithms are from the period 1956-65. I have tried to collect as many of the original papers as possible, and these now reside in the papers folder of this repository - this addition does make this repo very large, however, these pdfs are only included in the git repository, and not in the package available on npm. Many of these algorithms are taken from Robert Sedgewick's 1977 paper Permutation Generation Methods.

Along with the algorithms themselves, now translated from ALGOL into JavaScript, there are a series of utilities, designed to make the use of the algorithms easier. These include a small program that allows the easy replacement of the elements within an array of permutations·

github repository

Coding: Website

Brion Gysin's Permutation Poems (2019)

http://www.davidpocknee.com/gysin

React

This is a website that investigates the history and technology of the visual artist and writer Brion Gysin's Permutation Poems. Part of this project has involved collecting together historical permutation algorithms. These have been released as a JavaScript library and can be found ongithub and npm.

Between 1958 and 1982, Brion Gysin wrote a series of 43 Permutation Poems, in which the four or five-word title of the poem would be permutated into some or all of its possible orders. Some of these permutation poems were run through a computer, making them very early examples of computer-generated poetry. Prior scholarship on these poems has frequently failed to recognise that there are several different versions of each poem, which has led to an inaccurate dating of many of them, and a misunderstanding about the role of technology within all of them. Additionally - and probably most importantly - the failure of prior research to contextually situate this work within the history of early computing has led to an undervaluing of its technologically pioneering and progressive nature, as well as the significant difficulty that was overcome when producing this work in the mid 1960s. I attempt to correct these problems by providing the first accurate comprehensive chronology and bibliography of these works, along with an in-depth look at technical implementations of permutation algorithms in this era.

github repository

http://nfo.ricercata.org

The New Fordist Organization website (2013 - present)

html, css, php, javascript

Coded by David Pocknee | Design by Ana Smaragda Lemnaru

Website for the artist collective The New Fordist Organizationproviding information about the collective as well as presenting information and content about their 2013 residency at GEMAK gallery in The Hague.

www.davidpocknee.com/every

Every Composition Tool (2018)

ReactJS, webaudio, html, css, php

Designed and coded by David Pocknee

A tool designed to help compose my guitar piece "Every", by allowing the user to drag and drop all 319 chords in the piece into an order of their choice. A sythesized version of the re-ordered piece (algorithmically spliced together from samples) can then be played back by clicking the play and stop buttons in the bottom right of the window. The slider in the bottom left of the window can be used to choose the chord from which this playback starts. After the user has decided upon an order of chords that they like, it can be converted into musical notation in the liypond format by using the controls at the bottom of the window. This app was built with ReactJS and the webaudio API with a php backend.

http://www.acesinstitute.eu

The Institute of Applied Cultural Economics and Sociology website (2013 - present)

html, css, php, javascript

Coded by David Pocknee | Design by Ana Smaragda Lemnaru

Website for the independent research organization Institute of Applied Cultural Economics and Sociology.

http://aces.ricercata.org/textscoreaday/

@textscoreaday Online Calendar (2015)

html, css, javascript

Coded by David Pocknee | Design by Ana Smaragda Lemnaru

An online calendar based upon tweets from the http://www.twitter.com/textscoreadaytwitter account. This account was set up by a group of five composers and visual artists who posted an experimental text score to this twitter page every day for an entire year. The project started on October 12th 2012 and ended on October 12th 2013. This calendar automatically shows a different tweet from this project every day and the arrangement of date and text randomly changes each time the page is refreshed.

http://mtmn.ricercata.org/ mtmn005-selfhelp-online

Online version of my book Self-Helplessness (2017)

html, css, Emacs lisp

Designed and Coded by David Pocknee

An online version of my choose-your-own-adventure self-help book. The pages were algorithmically created from the .csv file that was used for the paper version of the book using Emacs lisp. Specifically designed to work well on mobile devices.

http://mtmn.ricercata.org

Much Too Much Noise website (2015)

html, css

Designed and coded by David Pocknee

Website for the online publishing organization Much Too Much Noise. A simple, one-page website using just html and css.

Coding: Max/MSP and Puredata Patches

New Fordist Painting Software (2013)

http://nfo.ricercata.org/ web/technologies/ painting

pure data

New Fordist Painting is an easy-to-use technique for creating a painting. By analyzing an image and deconstructing it into individual brush strokes, the New Fordist Painting application reduces all the steps that would take hours of preparation and training to a couple of simple gestures.

The number of layers of color in the painting should be determined and reduced if necessary, using the color reduction tool built into the software. Then, other variables can be set as well: brush size, maximum stroke length, angle and variation.

At this point, the analysis can begin. Once the analysis is completed, the results can be saved into a text file. The time needed to complete the painting is displayed in the program, as is the amount of paint needed.

When the live paint begins, the result of the analysis will be displayed by a projector on the canvas: a flashing rectangle will appear on the screen, showing the area that needs to be painted.

This software was all built within puredata.

New Fordist Orchestral Composer (2013)

http://nfo.ricercata.org/ web/ technologies/ orchestra

Max/MSP, javascript, fomus, lilypond, MIDIOx, Cubase

New Fordist Orchestral Composing is a process whereby a MIDI controller is used to create orchestral works.

The controller manipulates the live synthesized MIDI sound of an orchestra. Each slider, button or knob controls a different musical parameter.

As the synthesized version of the piece is heard and manipulated, the program simultaneously notates all the sounds heard and records the synthesized MIDI sounds.

When the piece is finished, the notation file is then rendered as a .xml or lilypond file and cleaned up in a music notation program, before being exported as a .pdf.

Coding: Plugins and Macros

Handwritten Score Extractor (2012)

https://github.com/dpocknee/part_extractor

scheme plugin for GIMPimage editor, BASIC macro for OpenOffice Writer

This method is designed for the easy, automated extraction of instrumental parts from handwritten musical scores.
The process works by taking the scanned images of pages of your scores, copying the area containing a particular instrument from every page of your score into new files, and then compiling it into an OpenOffice word file.

This method uses two, free, open source programs, available for both mac and PC:
- The GIMP image editing program.
- The 'Writer' word processor from the Open Office office suite. Available from Open Office. Will not work with versions of Open Office lower than 2.6.8.

This process utilises two scripts:
1. A script for GIMP which extracts the parts into separate files.
2. A script for OpenOffice which compiles them.

The scripts and instructions can be found on github: https://github.com/dpocknee/part_extractor

The video shows how the scripts can be used once they are installed and what they can do. I use an example of a 20 page score for 5 instruments on A4 paper in landscape orientation and extract a violin part into a new OPenOffice document in A4 Portrait orientation.

All files for the score are kept in the folder 'Score' on the Desktop. I extract the violin part from this score using GIMP, which saves all images in a new folder named 'Violin Part' on the Desktop. Then OpenOffice is used to compile all the images together into a part in A4 Portrait orientation.