Month: January 2015

Threads and Codes Symposium at Goldsmiths, London, March 6th 2015

Research symposium: Threads and Codes
http://kairotic.org/threads-codes/

10am-6pm, 6th March 2015
137 Richard Hoggart Building, Goldsmiths, New Cross, London SE14 6NW

The symposium is now full. Please use the comment form to join the reserve list.

The Weaving Codes, Coding Weaves project explores the practices of weaving and computer programming together, considering both looms and computers as algorithmic environments for creative work with pattern. The connection between computing and the Jacquard loom is well known, but we want to go deeper in history and philosophy, to investigate traditional work with threads for its digital nature, including the genesis of discrete mathematics in ancient looms. This will provide an unravelling of contemporary technology, finding an alternative account of computer programming with its roots in arts and craft. On this basis this symposium will investigate contemporary theoretical points where textile and code-based crafts connect.

All interested researchers and practitioners are warmly invited to join us for Threads and Codes, an all-day symposium which will consist of diverse talks and panels exploring the above topics, co-organised by Dr Ellen Harlizius-Klück (International co-investigator), Dr Alex McLean (principal investigator) and Prof Janis Jefferies (project partner). The results of the symposium will feed into a special issue of Textile: The Journal of Cloth and Culture.

Confirmed speakers

We will update with the full programme soon.

Weaving Codes, Coding Weaves is a Digital Transformations project funded by the Arts and Humanities Research Council, UK. For more information on the project, see http://kairotic.org/

3D warp weighted loom simulation

One of the main objectives of the weavecoding project is to provide a simulation of the warp weighted loom to use for demonstrations and exploration of ancient weaving techniques. Beyond the 4 shaft loom dyadic calculator we need to show the actual process of weaving to explain how the structures and patterns emerge. Weaving is very much a 3D process and these visualisations fail to show that well. It also needs to be able to be driven by the flotsam tangible livecoding hardware so running on a Raspberry Pi is another requirement.

Sketch and rendering

I’ve decided to make use of the Jellyfish procedural renderer to build something fast and flexible enough, while remaining cross platform. Jellyfish is a lisp-like language which compiles to a vector processing virtual machine written in C++, and approaches speeds of native code (with no garbage collection) while remaining very creative to work with, similar to fluxus livecoding. Previously I’ve only used it for small experiments rather than production like this, so I’ve needed to tighten up the compiler quite a bit. One of the areas which needed work (along with function arguments which were coming out backwards!) were the conditional statements, which I removed and replaced with a single if. Here is the compiler code at the lowest level which emits all the instructions required:

;; compiler code to output a list of instructions for (if pred true-expr false-expr)
(define (emit-if x)
  (let ((tblock (emit-expr (caddr x))) ;; compile true expression to a block
        (fblock (emit-expr (cadddr x)))) ;; compile false expression to block
    (append
     (emit-expr (cadr x)) ;; predicate - returns true or false
     (emit (vector jmz (+ (length tblock) 2) 0)) ;; if false skip true block
     tblock
     (emit (vector jmr (+ (length fblock) 1) 0)) ;; skip false block
     fblock)))

Then I can implement cond (which is a list of different options to check rather than one) as a purely syntactic form with a pre-processor function to create a series of nested ifs before compiling them:

;; preprocessor to take a cond list and convert to nested ifs 
(define (preprocess-cond-to-if x)
  (define (_ l)
    (cond
      ((null? l) 0)          ;; a cond without an else returns 0 
      ((eq? (caar l) 'else)  ;; check for else clause to do
          (cons 'do (pre-process (cdr (car l)))))
      (else (list 'if (pre-process (caar l)) ;; build an if
          (cons 'do (pre-process (cdr (car l))))
                  (_ (cdr l)))))) ;; keep going
  (_ (cdr x))) ;; ignores the 'cond'

Here’s an example of the if in use in the loom simulation at the ‘top’ level – it gets the current weaving draft value for the weft and warp thread position and uses it to move the weft polygons forward or back (in the z) a tiny amount to show up on the correct side of the warp.

 

(define calc-weft-z
    (lambda ()
        (set! weft-count (+ weft-count 1))
        (set! weft-z
              (if (> (read-draft) 0.5)
                  (vector 0 0 0.01)
                  (vector 0 0 -0.01)))))

 

One of the reasons I’m writing about all these levels of representation is that they feel close to the multiple representations present in weaving from draft to heddle layout, lift plan, fabric structure and resulting pattern.

Coding structure with threads

IMG_1532

One of the most inspiring things we heard from Leslie Downs (our Advisor on textile innovation) was about the way he manufactures high specification structures for aerospace engineering by weaving on ordinary looms, sometime even hand looms for their flexibility. It turns out that some of these techniques are also possible with tablet weaving: I came across this mysterious diagram in ‘Byways in Handweaving’ by Mary Meigs Atwater:

IMG_1537

Continue reading Coding structure with threads

Hack the City

Hack the City is a series of events in Sheffield about using open data for a better urban and civic experience. Their next hackathon is taking place this Saturday 10th January 2015, and we will be teaming up with the Live Coding Research Network to bring a diverse team of live coders and textile artists together to turn open data into performances, knitwear and whatever else we can think of, as counterpoint to the more conventional hackathon activities such as app building.

Participants include:

  • Antonio Roberts (aka hellocatfood; Birmingham), live coder of glitch art reknown
  • Amy Twigger Holroyd (University of Leeds), not only a knitter but a reknitter, who uses knitting techniques to rework existing, often machine-made garments
  • Nora o Murchu (University of Limerick), whose new Open Source Aran project fits this event perfectly
  • Francesca Sargent (Falmouth), part of FoAM Kernow and hacker on our Weaving Codes, Coding Weaves project
  • Joanne Armitage (University of Leeds), composer and PhD candidate with research interests which include in haptic/vibrotactile feedback in music performance
  • Shelly Knotts (University of Durham),  live coder, composer and curator in network and algorave music
  • Holger Ballweg (Northumbria University) from the German live coding band Benoit and the Mandelbrots of legend
  • Rodrigo Velasco (University of Leeds) is a practitioner of on-the-fly codepoetry and live coding, on a research visit from Mexico City.
  • Helen Thornham (University of Leeds) is a researcher and ethnographer whose interests include transformative use and appropriation of new media, and feminist new media theory.
  • Sam Meech (Manchester) is an artist, videosmith and knitter whose many projects include knitting digital.
  • Victoria Bradbury (CRUMB, Sunderland) is a new media artist working in the intersections between code, body and object.
  • Plus myself Alex McLean (University of Leeds), live coder and so on.

We hope our participation in this event will beget strange and wonderful surprises, which we will develop towards a standalone Code and Craft Hackathon in the future.