Five software acts synopsis 12:31 (2006.05.18:1)

Five acts enabled by differing open software constellations.

Based on PLENUM, xxxxx

The five exposed software acts, verging on the coded operatic as pinned down by plenum, explore the interface between the realms of ever hopeful expanded software and reduced contemporary code; an exchange rooted in the heavily textual notion of scripting. Each act is to be rendered in real time (primarily using the audible as our time base) by five demarcated and differing sets of exposed software assemblages. Such machinery will be assembled in modular fashion using visible Pure Data (PD) patches, custom coded commandline applications chained into new code formations and specific applications of computer languages, alongside well established ap environmental code. The discursive quite obviously enters into the equation within the experiment which is presented by five software acts; an opera with neither performer nor audience, but rather all participants within a code laboratory. A rough outline for the five acts could be sketched as follows:

0) Prelude

Without giving background to R.W. Fassbinder's In a Year of 13 Moons, a singular scene attempts to expose our layering or reframing summarised by "the record player on stage." Where is the script? The elements are all here; philosophy on the walls, curtains obscuring daylight, a silhouetted body-builder lifting weights in slow motion, fake moustache, prostitute and man become woman. A lengthy scene, played out for audience provocation, beginning with Ingrid Caven's spinning top, a dream recounted. "Maybe I didn't dream it at all. Maybe I only heard it or read it somewhere. It doesn't matter." A tape recorder is switched on, dialogue concerning the difference between "real life" and living -- or "real music" and music while Suicide's "Frankie Teardrop" plays. Alan Vega's scream. Song lyrics. Seven minutes 40 seconds. Execution and coding.

1) Substance

The first questions of interface are raised at the level of an imagined neural trigger, an imagined dynamic which could be exposed, a tonality. Escalation is first broached by discussion and by software.

Languages and protocols are exchanged and tried on for size. Codified software switches into leakage and the social becomes heavily protocol driven; operatic speech, drawing room sensibilities, yet all under the banner of substance or vertiginous term/domain exchange/crashing which is maybe the same thing. There is no part or counter-part.

2) Alice: Coded rabbit holes. Spoken word and speech synthesis

Coded rabbit holes. Spoken word and speech synthesis.

The script is interrogated and opened up to ridicule. The code is full of (rabbit) holes and sample transformations. Our pleasant neural system now accepts wild triggerings. A tea party.

3) Jekyll and Hyde

Jekyll assumes sampling or data slicing a la slow scan image-sound, piping and leaked and labelled containers. Timeslice audio laid open to inspection. As from a distance, from within the train carriage, distant objects maintain their place, whilst those closest rush past, a similar spectrum will be attempted. In addition the exterior scene can be moved with no train motion. Time slicing and distance. Multiple versions of the same software will be showcased with reference to the multiple edits and censorsnips concerning Docteur Jekyll et les Femmes (1981). Walerian Borowczyk.

4) H bomb simulation/audience simulation catastrophe

Simulation is made evident through noise and spatialization. The audience is in the patch/code. Code audio is broadcast into the audience simulating space; where are the microphones recorded in the machines placed in simulated space and now heard in the room through two speakers?

Simulation at entry point/interface into the machine. The participants in our expanded software must be mapped into the computer model. Where they meet is the (ugly) interface. What the machine can know is important for its mapping. For example if the microphones are moving the machine doesn't know where they are (unless we code in very complex algorithms that would compare background noises - simulating space is easier than reading space) - unless we at the interface say so - ie. we humanly trace it - or we use some machine vision or some kind of interference pattern. Noise or waveforms suggest themselves.

War time simulations-theory and game theory circa code war escalation could be recounted here.

5) Pink light

[The Thames walk. A code graveyard. The repository is symbolically drained.]

GNU Emacs as multi-process-driven spider OSC-enabled to all PD and friends 11:52 (2006.05.17:4 emacs#6 tech_notes#128 five_software_acts#2)

with reference to Distel but we don't really want to dig into Erlang...

looking at http://fresh.homeunix.net/~luke/shbuf/ which allows for shared Emacs buffers on top of Distel....

client.server application with serveur written in Erlang

also Termite on Gambit Scheme

or even simpler is Paul Graham continuation-led code in lisproc.lisp to be investigated [attempt for panel module to wrap up with querying, speech and OSC/PD macro]

five software acts 15:00 (2006.05.16:3)

see also plenum and xxxxx_plenum

research material also relating to pure data [PD] and pluggability/promiscuity -> one element thus of promiscuOS

older pluggability notes from tech_notes ::

pluggability and software acts: 18:14 (2006.05.04:1)


1] rehearse micro/macro operations in PD

2] parameter attachment question for commandline apps (eg. self/otherwise coded granular synthesis/neural nets) - answer is OSC with Common Lisp as glue code and shell also (scheme shell as possible: see http://www.scsh.net/ and below

3] PF - attempt PD to PF glue using example frames/mencoder code

first up: PF arguments from pd after init word

: init
#"initializing with args: " . . cr 


        >int 2 max frames !
	>int 2 max accum !
	"speedup = " . accum @ . .n
	"frames  = " . frames @ . .n

finally getting to grips with Forth and all DUP and so on

thanks to tutorials such as:


second up: modified mencoder example (timelapse.pf) works ok under plain old PF but hangs when in PD (also won't accept argument open "/path/file.avi" message. First instance must be some pipes issue or mencoder falls over - seems like latter instance as catting to tmp file used by PF offers results with mainloop, grab and blit

... was bad .avi file so fixed up now and code functions

thus PF/PD could be used as glue code for OSC-enabled lisp image/video functionalities

pf and evilwm to investigate 18:16 (2006.05.03:2)

pf audio glue -> pd

need some kind of CL environment - staging for opera/promiscuOS with abstracted I/O and networked execution. PD as sound engine, glue - with or without PF?

inf-snd.el 18:07 (2006.05.03:1)

snd guile as inferior lisp

cur as guile embedded would need to use threading 17:04 (2006.05.03:2)

thread out sound engine.

new approach to cur: strip down code, new interface, infrastructure

Five software acts 12:33 (2006.05.03:1)

Operatic - based on five PLENUM acts:

0) Prelude - as always Frankie Teardrop

1) Substance - i_am_a_neuron

[tune command-line tools]

2) Alice: Coded rabbit holes. Spoken word and speech synthesis
[ The script is interrogated and opened up to ridicule.
The code is full of (rabbit) holes and sample transformations.]

[Pure Data and Lisp code]

3) Jekyll and Hyde - Time slicing and distance

[command-line and ??]

4)  H bomb simulation/audience simulation catastrophe.

[Simulation is made evident through noise and spatialization. 
The audience is in the patch/code.]

[Pure Data] ????

5) Pink light
[The Thames walk. A code graveyard. The repository is symbolically drained.]

[cur + more granular stuff]

PF (packet forth) tests using rawvideo.pf example for interface to mencoder. 18:04 (2006.04.18:1)

1] had to make some changes to pf-rawvideo.mencoder shell to use mktemp rather than tempfile and to lose scaling from mencoder which didn't work (thus had to put size into rawvideo.pf:

: grab 	
	` bitmap/i420/544/400 stream @ read-raw-packet 		# grab raw bitmap from stream
	>image ;						# convert to image
	"( -- image )\tGrab next frame." doc

2] then in pf:

"/path/filename.avi" open tv

next steps to work with frames

(setq inferior-lisp-program "/root/tor") 20:23 (2006.04.14:1)

tortoise example for guile runs from emacs as inferior lisp:


needed to recode deprecated SCM_NUM2DBL as:

eg. steps = scm_num2dbl(s_steps, __FUNCTION__);

to avoid: undefined reference to `SCM_NUM2DBL'


guile-config link

thus a guile-enabled cur or first stages towards fm01 could run on guile in emacs...

gut out GUI from cur and throw in guile - how variables are handled? - see tortoise example

look also at snd guile-enabled sound editor

more sc, pd, connectivity: 12:12 (2006.02.24:1)

1) k_guile (with reload) for pd is interesting though how we can control running guile instance? how differs from pd-scheme which is more like embedded interpreter

2) looking through this thread:


a) mention of qlist which works with text and sequencing (in time)

b) mention of Todd Ingalls:

cm to sc:



packet forth pf link: 17:22 (2006.02.22:5)


in latest darcs pull now pf->pd connection works as it should

see example.pf -> pd object as [pf example.pf]

in libpf/puredata/doc

and pf.pd (though take care with all paths)

but as pf object is defined by a file it doesn't really take us into emacs territory..

ie. pf is embedded within pd

is it possible to communicate with this process? if so, how and in what form

(other than editing file and reloading the patch or edit/unedit pf object)

guess what want is something like sc node IDs attacked by OSC stuff from pd

pd->sc/ssc and we also have the eval thing - EvalListener

but want to be able to eval ssc/scheme - need to dig much deeper into this

ssc, sc and friends 12:31 (2006.02.22:1)

1) now back to port 57120 for sclang. maybe binds above this if port is occupied (eg. by pd)

2) doesn't seem any way to automate:

    (sclang-eval-expression "EvalListener.init")
and any changes to ssc.el to do sclang-eval-expression rather than string don't seem to work interactively

SC3 15:06 (2006.02.21:1)

finally up and running with SC3 (SuperCollider), SCEL and Emacs - latest CVS compiled with:

1) scons install

2) ditch all config files mentioned elsewhere just .bash_profile:

export SC_LIB_DIR=/usr/local/share/SuperCollider/SCClassLibrary
export SC_JACK_DEFAULT_INPUTS="alsa_pcm:capture_1,alsa_pcm:capture_2"
export SC_JACK_DEFAULT_OUTPUTS="alsa_pcm:playback_1,alsa_pcm:playback_2"
export SC_SYNTHDEF_PATH="./synthdefs"
3) and then emacs -sclang (have (require 'sclang) in .emacs)

start jackd -alsa obviously

4) sample code from:


runs fine

next up is how to connect to Pd (is it just by way of OSC?) and then base command-line OSC experiments (problem is send and dump bind socket)

k_jack~ possibly as interesting:


This external makes objects with signal inlets and outlets to jack ports. See the help patch.

we can see as example DG Fluxus OSC->Pd by way of Scheme at:


but we also have artm's code to OSC and PLT or other Scheme OSC somewhere

1) emacs -> cm (common music) -> sc (by way of osc) -> pd




2) rsc scheme supercollider client:

rsc 1 is a set of extensions to the PLT Scheme implementation 2 that facilitate using Scheme as a client to the SuperCollider 3 synthesis server. The rsc interaction environment is written for GNU Emacs 4.

new URL:



a) installed by copying files to new dir:


and then run make seems ok.

b) and do usual path and (require 'rsc) in emacs

c) but just seems start up plain old mzscheme and have to load rsc by hand with:

(require (lib "rsc.cs" "rsc"))

and then can't seem to boot sc server or do much else as complains of s as unidentified symbol




ssc implements an s-expression read syntax for the SuperCollider language.

(also in PLT Scheme)

but- after building and so on when we try to start ssc-listener by way of make-ssc-client we have problem with mzscheme complaining of:

procedure open-udp*: expects 2 arguments, given 1: ("" 57120)

so got rid of ref to list in client.scm

and now will try with new 57122 port:::

ok now with 57121 port in ssc.el::::

as follows:

a) start emacs

b) ssc-start-scl

c) sclang-server-boot

d) sclang-eval-line EvalListener.init (with EvalListener.sc in share stuff)

e) ssc-start-listener

f) ssc-play marked region of:

 (lambda ()
   (let ((freq (midicps (kr LFSaw 0.4 0 24 (kr LFSaw #(8 7.23) 0 3
     (ar CombN (ar SinOsc freq 0 0.1) 0.2 0.2 4)))
but why is this not so automated on starting ssc stuff which should load evalistener???

3) pd to sc by way of OSC:

a) we have jackd/sclang in emacs running.

following: http://www.psi-o.net/pseudonym/synthdefs.php

we can define sine as:

s = Server.local.boot;

    SynthDef("sine", { arg freq = 440;

then in pd we have sample OSCx patch:

connect localhost 57110

and simple messages for server such as:

send s_new sine 100 1, 0

where 100 is the node ID

to switch off:

send n_free 100

and to make use of freq argument:

send n_set 100 freq, $1

what about messages the other way round emacs/sc to pd?

in that case must just be used OSC capabilties of SC

see also:



and thread:


can send from language to pd using:

n= NetAddr("", 9999); n.sendMsg("/test", 2345);

and [dumpOSC 9999] and [OSCroute /test] as in: http://www.create.ucsb.edu/pipermail/sc-users/2005-September/020931.html

but no luck with OSCresponder to receive messages sent to the LANGUAGE

using as example:

o = OSCresponder(NetAddr("", 9999), '/hier', { "hello".postln })



so looked into tcpdump -i lo and can see is port 57122 we communicate with lang on after sclang-start and server-boot

and also with:

OSCresponder(nil, "/hier", { arg time, responder, msg;

we can get the number from [send /hier $1] from pd


4) what we are trying to achieve

to step back - connectivity and integration as overarching software for xxxxx events and for future promiscuous OS:


a) workshop: pipes, ap and pd connectivity

b) xxxxx_on_a_wire: ap, pd and OSC. sniffing. hub. routing

c) alice paper: prolog knowledge-base in scheme. possible speech synthesis

d) PLENUM: 8 mics routing, jack, pd patch and OSC. integration of all of the above

-> exp promiscuOS platform for all above

existing software

a) emacs as central

b) command-line passing on/sampling/piping-OSC apps, sniffer - find URL>


also plain comint-run in emacs to commandline reader and then route this to pd or wherever

c) pd: OSC integration, speech synthesis, timelining and sampling

d) sc: perhaps better sampling, storage, triggering and general organisation of this. some integration with OSC and pd

but: would prefer scheme syntax and totally operational OSC

e) pf perhaps not so relevant but does tie into pd well and emacs also. guile as possibility to explore more

thus best options: emacs/sc under PLT scheme with working OSC tied into pd // or pf with guile tied into emacs and pd // or scheme to emacs and pd (by way of OSC) with self-defined modules and abstractions for routing and triggering

modules: alice, jekyll, substance, pink light (see below)

an obvious promiscuous and pluggable architecture???

useful SC URLS::

http://lalists.stanford.edu/lad/2004/10/0109.html - some SC live stuff



1) flite - library 14:18 (2006.02.20:1)

builds in different dir (Makefile complains also of missing lib on "make install")

so need to: cp build/i386-linux-gnu/lib/* /usr/lib

than we can wrap flite with pd-flite-0.1 and play with example patch-> text rendered to audio as buffer/table/array whatever

so we can have list/array of text and arrays of synthesised sound for cutups and timeslicing.

2) to begin to tie all elements together:

emacs->comint->pd: or to pf/pd as tom schouten shows:

(defun pf-buffer () (get-buffer "*pf*"))

(defun pf-send (start end) 
(interactive "r") 
(let ((buf (current-buffer))) (save-excursion (set-buffer (pf-buffer))
(insert-buffer-substring buf start end) (comint-send-input))))

(defun pf () (interactive)
  (make-comint "pf" "pf" nil "-")
  (switch-to-buffer (pf-buffer)))

(provide 'pf)

but then pd needs to be command-line client or we go through pf??

or emacs->scheme impl->pd // or in combination with above.

what elements/connectivity/pipes do we have?

a) piping by way of Unix pipes to and from applications/ commandline for example ap software. piping input to pd by way of piperead and write externals. how does piping work with emacs comint/shell stuff?

b) example commandline app could be jekyll sub-sampler. what is protocol for our piping of data? we can also connect with OSC and then we introduce messages. other commandline apps which could trigger messages if piped to triggerings

c) emacs as interface needs to impact on pd

d) pd is the other component. we can use speech synthesis and time-line. trigger. audio flows. our eight mics. and messages also

e) our language would be some Scheme which could also parse messages for OSC (re-)transmission

f) alice is our text. knowledge base for querying is entered in prolog-type language on top of Scheme and also parsing. middle layer.

g) pf may be needed to provide glue layer to pd:

in words of Tom:

Pf can be mapped to guile. This effectively enables all the powers of pf combined with scheme syntax, garbage collection and all kinds of sillyness.

h) archiving and storage (automated)

given additional leakage and kernel hacking: the result could/would be artistic OS/promiscuOS

some early notes/experiments:

a) pf maybe less appropriate as glue code to pd is deprecated. can't find clear examples for guile/pd mapping also

pdp console as object. [pf script] as object. but need inlets and outlets. also with no knowledge of Forth....

b) looked at k_guile. embeds own guile instance. check out pd-scheme

(also defining .pdrc for all necessary paths and libraries)

and needed some changes to SIOD to compile

can we attach from emacs?

c) also wondering if we use OSC as an infrastructure for data and messages then surely we don't need any glue - can just run from emacs/scheme

but then is message-passing rather than deep-integration (dressed up/undressed). need to define more what we want/need.

that we can define/alter objects in pd from emacs live. pipe all forms of data with protocol entry into OSC. chain pipes, processes and pd inlets with some degree of transparency from/to/with pd and emacs and alongside other processes

pd can send queries. sequential event queries to emacs/scheme

scheme can route messages and data to pd. also emacs as interface for further definition of query-resulting code

d) or: [from pd-list]:

"With my limited knowledge in both Lisp and network programming, the most obvious approach to me is to use the netsend and netreceive PD objects to communicate with a Lisp listener that is bound to a socket. I see, at least in Allegro, there are socket-stream CLOS objects implemented."



so guess could define/blackbox netsend/recieve within pd abstraction (eg. called alice) hooked into the REPL. or rather multiples of or multiple processes of.

or rather as usable entry points with live coding manipulation possibilities.

(but again this could be done with OSC)

e) we have possible command-line liblo ( http://liblo.sourceforge.net/ ) style clients

or sendOSC:


which is bundled in our ~/lunch/OSCx pd dir under send+dump

these need to be tested with pd patches