Software: Upcoming

UCS (Untitled Composition Software) (2023-present)

nim, faust

For the last few years, I have been working with Astrid Bin to create a new piece of composition software (currently untitled).

It is currently at the prototype stage. More information can be found on the UCS page.

Software

historical-permutations library on github

historical-permutations (2019)

javascript

github repository

npm package

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 superceded 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.

Dodecafinder interface

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 Austria and 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

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.

New Fordist Painting Software (2013)

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

pure data

TODO - revised 202???

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.

Handwritten Score Extractor (2012)

https://github.com/dpocknee/part_extractor

scheme plugin for GIMP image 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.