[Pixel]ate by Natasha Thapliya

[Pixel]ate is a series of images produced by the data visualization program called Processing. Processing is a programming language built from Java that combines code and visual outputs, allowing users to comprehend and execute computer programming fundamentals in a visually graphic way. [Pixel]ate aims to redefine how we experience and interpret digital imagery, placing those images in a pure programming context. It weds artistry and creativity with basic computer programming, using iPhone photographs as the work’s subject. The images used were edited minimally, but were run through Processing, with different snippets of code uniquely affecting each image. The output is a series of images that highlights the relationship between digital images and computer programming, emphasizing the artistic possibilities of code.

The artistic process also included a learning experience, where I was involved in teaching myself a completely new language, a programming language that is. I approached the challenge as a complete novice, not remotely aware of what I was getting myself into. I purchased a highly recommended “teach yourself Processing” textbook (Learning Processing by Daniel Shiffman) and dove in. I initially had the intention of not skipping any section, to “sticking to the book” so to speak, and to focus on one concept at a time. At the beginning of the process, it was very important to me that I understand every concept, every piece of syntax, and to get a solid baseline understanding of Processing. However, as I went on with following the book and recreating its exercises, I found myself itching to do more. I already knew of the capabilities of Processing, thanks to web artist Adam Ferriss. It was because of his work that my interest in Processing was born. I knew from the start that I wanted to experiment with imagery, as opposed to coding my own shapes and lines. About a month or two into the project I got impatient and skipped to the “Images” section of the book, which was 15 chapters in. I selected a few images from my phone I wanted to experiment with and continued from there. The output featured on my website is the result of that impatience, and a willingness to accept the fact that a lot of programming involves borrowing other people’s code, not dissimilar to the artistic process itself.

Art will always be influenced by other art; code will always have other people’s code within it; that is simply its nature. After using Processing’s built-in variables/features, I began to look to the web for Processing inspiration. I found a site called, OpenProcessing.org, where users post their Processing works along with its code. The site and community served as a perfect jumping off point for more of my creative/interactive pieces. But it was not as simple as “copy + paste.” Using other people’s code involved correctly and logically implementing their code into my own code, even if that included adding new variables. The learning process was not easy; numerous times the code stumped me and I felt helpless, mainly because I had a vision in my head of what I wanted the code to do visually and artistically, yet the language got in the way, and that was quite frustrating. Apart from the frustration, I carried on, seeking as much help as possible. I received help from online programming communities, other USC professors, and even my own family members. As far as the artistic aspect of the piece, the exposure to Internet art I received from this course helped me with maintaining an artistic perspective of the process as a whole. Each image featured has its own unique code, its own unique set of instructions on how to implement and execute. The final set of images are the result of pure experimentation and exploration that involved temporarily sacrificing the establishment of a solid foundation of the language. But that is simply the art of learning programming.