-
Notifications
You must be signed in to change notification settings - Fork 62
Week 4
This week we're going to talk about glitch.
Guest Kyle Machulis (Skype@11am)
Kyle is an engineer and hacker known for his pioneering teledildonics work, significant contributions to Second Life and other virtual environments, and for reverse engineering/liberating consumer hardware like Kinect (as OpenKinect), fitbit (as OpenYou), the Novint Falcon, and many others. He even got the electric slide released under Creative Commons. He's basically as close as you can get to a modern-day Superman without the spandex. Well, maybe there's a little spandex.
- VBOs and GPU accelerated rendering
- Show Justin's CT software
- mapamok preview
- I forgot to show some of the best laser cutting for 3d printing!
- How to use the XCode debugger
- How to use the OpenGL Shader Builder
- Informal openFrameworks vs Processing reference and architecture overview (single file example)
- Comparison of aamlib and FaceTracker
- Preview of eye tracking application
- If you're interested in learning Rhino (unrelated to this class, but related to 3d from last class) check out these tutorials and this workshop.
I am Sitting in a Room by Alvin Lucier (1969) allows the shape of the room to emerge from a feedback system.
Wounded Man'Yo by Yasunao Tone (2001) and Solo for Wounded CD (1997).
Databending is based on an important revelation: all digital data is a collection of bits (really, bytes). There is an equality between data in this sense: you can always "pretend" one type of data is another type, assuming that the format is sufficiently compressed (looks like noise) or completely uncompressed (can take any value). The name comes from circuit bending, pioneered by Reed Ghazala in the 60s.
"Databending" is most strongly associated in my mind with the Yahoo Databenders Group, which was most active in 2001-2003.
A good hex editor (e.g., Hex Fiend) is a almost a prerequisite for exploring this kind of glitch.
Phil Stearns has been working with circuit bent cameras and databent files for his Year of the Glitch.
Boyz by MIA by Weirdcore (2007)
Pixel Bleed overview from Rhizome (2009)
Kanye West gets scooped covered by MTV (2009)
forcing errors in Poser + Bryce
The most puritanical glitch theorist might say that engineering a glitch is impossible, as "pure glitch" is always "unpremeditated". These examples are given as demonstrations of common causes of pure glitches. I keep track of these whenever I see them.
Cory Arcangel uses this technique for Data Diaries (2002).
To understand what's happening here, we need to talk about memory: variables, references, and pointers.
Memory on your computer can be imagined as a sequence of bytes: [byte 0, byte 1, byte 2... byte n]. Each of these bytes has an address (or position) from 0 to n. Here are a bunch of things you can do with your memory:
char myChar;
- Your operating system will allocate 1 byte of space, because a
chartakes a single byte of space. It could be anywhere in memory. - This byte gets "tagged" with the name
myChar.
int myInt;
- Your operating system will allocate 4 bytes of space, because an
inttakes a four bytes of space (32 bits). - The first byte gets tagged with the name
myInt.
int myIntCopy = myInt;
- Like above, your OS allocates 4 bytes for the
int. - These 4 bytes get tagged with the name
myIntCopy. - The chunk of memory that is tagged
myIntis copied to the chunk of memory taggedmyIntCopy.
Hopefully you should see that variables are not the memory themselves. Variables are just nicknames for the memory. A single chunk of memory can have multiple nicknames.
int& myIntReference = myInt;
- This takes the chunk of memory tagged as "myInt", and adds a new tag called "myIntReference".
- This does not allocate any new memory.
char* myCharPointer;
- Your operating system allocates 4 bytes of space. This is because the memory being is going to store a pointer, and a pointer needs to be able to describe every possible address in memory. For a 32-bit system, it takes 32 bits (4 bytes) to describe every address. If we were on a 64-bit system it would take 64 bits (8 bytes) to describe every address, and our pointer would have 8 bytes allocated instead.
- The 4 bytes are tagged with the name
myCharPointer.
char* myCharPointer = &myChar;
- For the left hand side, the same things happen as above: memory allocation, memory tagging.
- On the right hand side, the
&symbol is called the "reference operator". This is a way of askingmyChar, "what is the address of the chunk of memory you're tagging?" - The
=operator saves the address ofmyCharin the newly allocated pointer.
The reality is more complicated due to things like CPU emulation in virtual machines, and data execution prevention (DEP). For a computer scientist's explanation of pointers, still excluding these exceptions, see "Pointers explained".
This is one of the most common pure glitches. To get this one running, you should try filling up your graphics card first with textures from a visually heavy application. I like testing with Nokia WebGL Maps or Google Earth.
This example ships with openFrameworks. It's based on a discussion with the creator of this image (who is also responsible for this image in the same style). The takeaway message is that re-compression isn't enough, you need to escape the block structure of JPEG encoding.
This example also demonstrates shot-noise/databend-style glitch via ofBuffer.
Glitch-alike is what happens when you pursue glitches intentionally; especially if you're interested in glitch aesthetic, but have not necessarily glitch as a process.
Randomness is often featured in glitch-alike work, drawing on the older history of noise. Here is an example of generating randomness without a built in random() function.
Bytebeat is a new subgenre within the demoscene that has emerged from one guy named Viznut who is on a personal mission to create what he calls computationally minimal art. It falls somewhere on the border between glitch, lo-fi, and demoscene. This example shows how to use a shader to livecode bytebeat. You don't need to understand how it works completely, but you're welcome to experiment with it.
This example is the most advanced of the bunch. It automatically generates bytebeat using the OneLiner class. Again, you don't need to understand how it works completely.
Jesus Gollonet has posted an addon for exporting animated GIFs from openFrameworks called ofxGifEncoder
Pick one or more of the following:
- Find a glitch online, and stare at it until you understand it. Recreate it. The Flickr pool is a good place to look. The easiest technique to reverse would probably be Kim Asendorf's pixel sorting aesthetic.
- Try to remember a glitch you once saw in your own code, and recreate it. Turn it into something you prefer over what you were originally trying to create.
- Take code that works, but that you don't understand, and introduce interesting mistakes into it. See the breakout workshop.
- How many different formats can you transcode (databend) your data between?
- Do all the reading (skimming through Moradi's thesis or Glitch Moment(um) as necessary), and write a one page blog post that contributes some new thoughts on glitch studies. Either by critiquing or synthesizing the perspectives you've soaked up from the reading, or by adding a new perspective from first principles, or incorporating other texts, or based on cultural observation.
- Take advantage of WebGL texture leaks for artistic purposes.
- Write a wrapper for any format (video, image, sound, etc.) that allows you to manipulate the data on its "own terms", so instead of mindlessly moving bits around, you only tweak things in highly controlled ways. Tame the glitch.
- Create a new file format that degrades in pleasant ways. See extrafile by Kim Asendorf.
- Connect your glitches to the physical or virtual environment. Can you make data degradation part of a natural, expected process? See temporary.cc by Zach Gage. Can you send your data into the real world, and bring it back? See Future Fragments
- Do anything with PDF. See Ben Fry's Frankenfont
I'm not going to exclude any techniques, but if you want to use something as generic as datamoshing your work better be incredible.
Finally, add a link to your favorite glitch project on the wiki.
The Art of Noises by the Futurist composer Luigi Russolo (1913) and the summary on Wikipedia
Noise by Simon Reynolds (1987)
Glitch Aesthetics by Iman Moradi (2004) as an undergraduate
Vernacular of File Formats by Rosa Menkman (2010)
Glitch Studies Manifesto 2 by Rosa Menkman (2011), originally from 2010.
The Glitch Moment(um) by Rosa Menkman (2011)