Spring 2012: v.08 n.01: CAA Conference Edition 2012
Code: Intellectual Property, Fair Use and Plagiarism

SPRING 2012: V.08 N.01: CAA Conference Edition 2012

 
Rachel Beth Egenhoefer
University of San Francisco, California

Joel Swanson
University of Colorado, Boulder

“Code as Craft” Panel Presentation, Rachel Beth Egenhoefer, speaking. (Used with permission.)

“Code as Craft” Panel Presentation, Rachel Beth Egenhoefer, speaking. (Used with permission.)

Introduction

The rise of digital arts programs within academia has caused a dramatic growth in the number of artists who are learning how to program and write code. Within the digital arts, programming is most often taught through code samples, tutorials, modification and adaptation. But this practice can become problematic if it fails to address the complexity of locating intellectual property and authorship within code. Additionally, these pedagogical methods carry their own ideological biases and assumptions. Frequently, instructors are shocked when students turn in projects that are largely copied with slight modification, but isn’t this ostensibly what we often teach them to do? As a result, instructors rely on regulatory practices designed for natural language, like plagiarism, but this reliance creates its own difficulties as assumptions regarding governing these practices in natural languages exhibit certain failings when applied to non-natural, or computational, languages.

Within the humanities, there are numerous and highly-detailed methods for citation (MLA, Chicago, etc.), yet within programming, there is a lack of standardized citation practices beyond leaving comments. This lack raises the question, how should originality and intellectual property be located within computational languages? There has been ample dialogue surrounding appropriation and Fair Use of imagery, but again, code operates at a different semantic and cultural level than traditional artworks do. For code – what is original – how should authorship be defined and demarked, and what concepts fall under the auspices of Fair Use?

This paper seeks to ask questions and raise awareness surrounding the complexities behind using, teaching and learning code within artistic contexts. The scope of this paper includes theoretical perspectives on the differences between natural language and code, legal perspectives on Fair Use and Intellectual Property as it relates to both digital and analog code examples, and pedagogical perspectives on teaching computer programming in the digital arts. It is our hope that raising the awareness of these issues will be beneficial for both instructors and students.

The practice of concern is how we teach programming to digital art students. Within most digital art programs, students learn programming through adaptation. An instructor may teach the basic fundamental concepts, but then students are encouraged to take existing code, and extend, modify or “play” with it as a method of learning and creativity. The Processing application (which is commonly taught in digital arts programs today) encourages users to learn through creative exploration of their reference, code examples and tutorials: “Learning how to program with Processing involves exploring lots of code: running, altering, breaking, and enhancing it until you have reshaped it into something new.” [1] Creative exploration of programming is a hallmark of pedagogy within the digital arts, and this practice stands in contrast to traditional methods, as employed within computer science, of teaching programming from the ground up. Creative adaptation is encouraged, and a result, digital arts programs can often struggle more with issues of intellectual property

Teaching programming through adaptation comes with its own set of complexities and ideological implications. For example, if we teach students that it is acceptable to take and modify code while learning, at what point can we definitively say that this practice is no longer acceptable? We can agree that a student copying several dozen lines of code, changing some variables, and submitting it as their own work is unacceptable. No matter what ideological beliefs we espouse regarding copyright or copy-left, most agree that turning in someone else’s program as your own isn’t appropriate for a class where the goal is to learn how to program. But then when, and how, do we articulate the point at which adaptation of found code is no longer acceptable?

Natural Language vs. Computer Language

It may seem logical to look to rules regarding plagiarism for clarity, but it is important to understand that natural languages do not operate according to the same rules and structure as computer languages. Specifying what may qualify as “original or creative thought” in computer languages, and therefore deserving of intellectual property protection, comes with its own set of complexities.

Despite the best attempts of some, we cannot claim intellectual property over a word or phrase. It is only when combinations of words and phrases becomes significantly complex and unique that one can claim intellectual property. It is silly to try to claim intellectual property over structural elements, phonemes, phrases and syntax that are the building blocks of language. But at the same time the line at which a thing becomes “significantly complex” is not clear, as many legal cases regarding plagiarism have shown.

In her book, My Mother was a Computer, theorist N. Katherine Hayles has written about the critical differences between natural languages and computer languages. She writes, “…code differs from speech and writing in that it exists in clearly differentiated versions that are executable in a process that includes hardware and software…”. [2] Alex Galloway defines code as “the only language that is executable,” which stands in contrast to natural languages that are not executable, or descriptive in nature. [3] This contrast is significant as the systems designed to prevent the miss-appropriation of ideas (plagiarism) are based on the conventions of locating authorial ownership with natural language. It is problematic to use a system oriented towards natural language to locate intellectual property within a non-natural or computational language. Representation in natural language is radically different from representation in computational languages, and therefore different methods for defining ownership/authorship must be employed.

Where is the “idea”?

Hayles definition of computational languages as “clearly differentiated versions that are executable” raises the question of where, if at all, an “idea” exists within code. [4] Is the idea in the code, the execution of that code, the output or visualization of that code, or some combination thereof? If two people arrive at the same exact outcome using different code to get there, are these copies? Which “differentiated version” takes precedence over another?

Recently digital artist Robert Hodgin published images of flocks of birds made in Processing to his Flickr account. [5] Several months later these same images were reproduced on high-end clothing designer Paul Smith’s line of shirts. Did Smith take Hodgin’s image from the code or did he use Hodgin’s original code to generate his own images? Hodgin admitted, in full disclosure, that he did not produce his images by himself, but borrowed bits and pieces of code from others. What intellectual property was appropriated by Smith and on what grounds does Hodgins have legal recourse if any? Hodgins published the code on his website, so did this only become unacceptable when Smith started to make money off the t-shirts?

Knitting patterns is another area where questions of authorship are raised (and there is an interesting historical relationship between textiles and computing in general).

As with computer code, some might question where the work exists in a knitted pattern. Is it in the pattern (or code) itself, or in the physical manifestation of that pattern (output)? Currently, written patterns, step-by-step instructions, photographs, charts, and diagrams are all copyrighted, in addition to the finished piece. Therefore, if one knits a hat from a pattern, he or she technically cannot sell it or claim it as his or her own. In knitting, the argument can be made that the way one executes the code (or knits the pattern) can produce a wide range of variation based on the yarn choices, technique, how loose or tight the stitches are done, and other variables. Knitting patterns raise the same question as computer code: how much does one have to change something to make it one’s own?

Author and Ownership

When we talk about the problems surrounding intellectual property and code we are really talking about the problems of authorship and ownership. As Barthes stated in his seminal essay from 1977, “The Death of the Author,” the function of author as owner, both of property and of meaning, has ceased to exist as it was once understood. [6]

When Barthes pronounced the “Death of the Author” he was articulating the death of the author function, not of authorship as the practice of writing. Foucault makes this more explicit in his 1977 essay “What is an Author.” Especially within New Media, much has been made of remix and appropriation, which are contingent upon Authorship/Ownership as a legitimizing structure. There would be no remix or appropriation without the author/owner function, and as such reify the ideological paradigms upon which they are based. That is not to say that there isn’t a significant and culturally important body of work that employs remix as an artist methodology, just that it relies on (and perhaps reifies) the very structures it attempts to critique. So perhaps the “Death of the Author” has merely been replaced by the birth of the “Owner” in today’s remix culture. It’s not about who made it; it’s about who owns it, or perhaps who last retweeted it.

How much mix to Re-mix?

Appropriation and re-mix culture has a rich history. Duchamp famously proclaimed that he was not the sole creator behind the objects in his Readymades. Warhol used countless images that were taken from advertising and popular culture in his screen prints. Sherrie Levine famously photographed Walker Evans photographs and presented her work as “After Walker Evans.” While most of these works are seen to have created something new (especially when viewed through the lens of history), other artists have been called into question for similar practices. Most recently was Richard Prince, when a federal court ruled that his appropriated images were in in violation of copyright. [7] One might argue that the difference with Prince’s work is how the images were appropriated and if his sources were “properly” attributed. Duchamp didn’t invent the wheel or the urinal, and Warhol used brands and logos in his work that obviously were not his. Levine named all her works after the Evans originals. So was the “mistake” on Prince’s part to neglect attributing the images to photographer Patrick Cariou, or was the omission something related to his method in general?

While legislation continues to attempt to address the slippery slope of intellectual property, it is clear that remix and appropriation is an important and increasingly accepted part of our culture. “Locking down” and copyrighting every image, word, note, letter, and function will not solve these problems, and would also take away the rich creative production that remix offers. Appropriation and remix allows people to raise questions in, create parody and introduce new ideas.  As a methodological frame, remixing allows artists the opportunity to engage, and thereby critique, the ubiquitous practice of remix that networked technologies have facilitated.

But younger generations do not understand remix in the same way as previous generations. Our students don’t see using images from the Internet as a “subversive or critical remix practice.” They simply see it as the de-facto way to produce creative work. Appropriation is now the norm, and as a result, words like “appropriation” and “remix” are losing cultural relevance.

Open Source Doesn’t Solve the Problem

“But it was from Creative Commons.”… “I used open source code.”… “It was royalty free.”… These are all phrases we’ve heard from students, or maybe even ourselves. The Open Source movement tends to come to mind as a possible solution to proprietary and “for-profit” approaches to locating intellectual property within code. However, the Open Source movement doesn’t solve the problem; it merely shifts the value system that is attached to authorship. Just because someone isn’t paid for specific programs, or segments of code, doesn’t mean it isn’t necessary to attribute code to specific authors. For example, when working collaboratively, it is necessary to attribute code to its programmer so inquiries can be made about certain programming and design decisions and so that responsibility can be taken if something isn’t working. All of these things take place in both the for-profit and non-profit (open source) programming structures. While Open Source practices are important as a collaborative model of production, and as an alternative to capitalistic commodification, they do not fully address the question of locating intellectual property in code.

Pedagogical Implications

There are many clear advantages to teaching, learning and creating through the act of modifying existing code. One can quickly see how examples work, save time not having to repeat small tasks, collaborate and share with others, and contribute to an open dialog in a creative environment. The practice of sharing code fosters learning and creative thought and presents alterative ways of teaching code beyond right or wrong solutions. However, there are pedagogical implications to be considered. How can the appropriation of code be used in a way that teaches and informs, while creating something unique and creative? How can we ensure that our students are giving proper credit where credit is due? As people who are called to teach programming, often to non-technically minded students, it is imperative that we as educators ask ourselves what ideological implications our pedagogical practices promote.

Most universities have strongly worded policies regarding plagiaristic practices. But few universities or art schools have robust policies regarding the improper use of code. There are programs that can detect copying in code. MOSS (Measure Of Software Similarity) [8] is a program often used in Computer Science classrooms that detect copied code in twenty-five some coding languages. This could be useful in detecting large amounts of work that already exist elsewhere. But this solution doesn’t address the larger question of how to define intellectual property in code. Some code is simply structural and is fine to be copied. Other code exhibits unique and creative thought and should be considered intellectual property. Distinguishing between the two is difficult.

Regarding citation, what would a standardized code citation system look like? Should every source be cited? Should code works include an annotated bibliography of the sources, ideas, and images that influenced each new work? These are all complex questions given the fluidity and multi-layered nature of code.

Younger generations have radically different understandings of authorship and ownership, especially when it comes to digital media. Our students’ lives are saturated with social media that is built upon the methods of appropriation and remix, even though they may not define their practices using those terms. Images posted to Facebook walls can instantly sprawl onto millions of other walls. Tweets are retweeted, and Tumblr images are tumbled. Appropriation and remix are the inherent ideology of social media. When pictures of cats with inspirational quotes or political figures with Photoshopped images are posted, liked, re-posted, retweeted no one seems to question, “Who made the original?” The origin of a thing isn’t nearly as important as it once was, so how do we teach our students the foreign concept of attribution when they are living in a sea of digital mashups?

There are times when this naiveté toward authorship and ownership works against younger students. A student in one of our classes received a cease and desist letter from BMW after creating a website for her design portfolio. While the website had nothing to do with cars or motors and in no way appeared aesthetically the same as BMW, her crime was simply having the same initials as the car company.

Outside of the realm of digital art, we see this happening more frequently. Recently it has been revealed that the Susan G. Koman foundation, who’s main goal is to raise money for breast cancer awareness, has also spent millions of dollars on lawsuits going after other charities (of all kinds) for using the words “for a cure” which they hold ownership over. [9] There will always be cases of the giants going after the little guys, but how do we prepare students for this world encouraging them to be creative and crafty, but cautious of those who don’t share their sensibilities. Our students may not be concerned about authorship and ownership, but the world they are about to enter does.

Additionally, and perhaps this is the most important question: How can instructors assess learning when so much of the work turned in is appropriated code? How do we know if a student spent hours figuring something out, or if she simply adapted something found online? At the heart of this discussion is that we as instructors, are supposed to be teaching, and students are supposed to be learning. There is real value in being able to integrate various bits of code together, but at what point are students avoiding learning outcomes by simply copying and pasting? How can we truly assess learning, understanding and growth when teaching how to program?

Conclusion

In conclusion, we have no conclusion. Our goal was merely to bring these questions to light. As educators, it is our responsibility to ask these questions and to understand the histories, structures, and ideologies that surround them. Beyond teaching software and technical tools, we also need to teach students to be critical of what they are making and how they are making it. Ultimately, it will be up to our students to answer these questions for themselves.

References

1. “Getting Started \ Processing” accessed March 11, 2012, http://processing.org/learning/gettingstarted.
2. Hayles Katherine N, My Mother Was a Computer: Digital Subjects and Literary Texts (University of Chicago Press, 2005), 52.
3. Galloway Alex, Protocol: Or How Control Exists After Decentralization (Massachusetts Institute of Technology Press, 2004), 65
4. Hayles Katherine N, My Mother Was a Computer: Digital Subjects and Literary Texts, 52
5. “Its like I made it myself!<< all manner of distractions” accessed March 11, 2012 http://www.flight404.com/blog/?p=135.
6. Barthes, “The Death of the Author,” Aspen, no. 5-6 (1967).
7. “Apropos Appropriation,” accessed March 11, 2012, http://www.nytimes.com/2012/01/01/arts/design/richard-prince-lawsuit-focuses-on-limits-of-appropriation.html?
8. “Plagiarism Detection,” accessed March 11, 2012 http://theory.stanford.edu/~aiken/moss.
9. “Susan G. Komen Foundation Elbows Out Charities Over Use of the Word ‘Cure’”, accessed February 22, 2011
http://www.huffingtonpost.com/2010/12/07/komen-foundation-charities-cure_n_793176.html