The Philosophy Of Software
Code and Mediation in the Digital Age
David M Berry
Palgrave Macmillan, 2011
ISBN 9780230244184
http://lab.softwarestudies.com/2011/04/new-book-philosophy-of-software-code.html

“The Philosophy Of Software” is an ambitious book by David Berry, who has turned his attention from the social relations and ideology of software (in “Rip, Mix, Burn”, 2008) to the question of what software means in itself. The philosophy that he has in mind isn’t the mindless political libertarianism attributed to hackers or the twentieth-century foundational mathematics that is the basis for the structure of many programming languages. It is a serious and literate philosophical reading of software and its production.

Software is an important feature of contemporary society that is rarely considered as a phenomena in its own right by philosophers. Software permeates contemporary society, Berry gives the examples of Google’s profits and the “financialisation” of the economy through software as examples of software’s importance in this respect. In reading this review on a screen you have used maybe a dozen computers, each containing multiple programs and libraries of software directly involved in serving up this page. Digital art and cyberculture often use and discuss software and philosophy (or at least Theory), but usually to illustrate a point about something other than software. The software itself is rarely the subject.

Rather than devote each chapter to a different philosopher’s views on software or adopting a pre-existing description of software Berry develops a novel and insightful philosophical approach to understanding and considering software. After providing an introduction to the foundational ideas and culture of software (Turing, Manovich, Cyberpunk), Berry presents a way of thinking through different aspect of software. The source code, the comments, the compiled program. Each stage and product of the lifecycle of software is given a philosophical context.

Heidegger emerges as the philosopher whose ideas first underwrite Berry’s approach to software. Latour and, in a surprising way, Lyotard play pivotal roles in later chapters. If these are not philosophers you were well inclined towards before then you are in for a pleasant surprise.

Berry presents some typographically appealing and culturally interesting code in order to demonstrate different features of the production of software. The swearing placed in Microsoft’s Windows source code comments by its programmers will mirror the frustration of many of its users. The Diebold voting machine code that illustrates the assumed social and gender roles of its human subjects show that code is very much a product of the social biases of its human authors.

Much of the code illustrated in the book is code poetry or obfuscated code. These are double-coded programs, where source code that can be run by a computer is written and formatted to be not just understandable but evocative and meaningful to human readers as something read rather than run. As with the comments in the Windows and Diebold code, a criticism that might be levelled at such code is that such textual decoration does not affect the compiled (or executed) form of the code.

But comments and formatting are what Berry refers to as commentary code and delegated code in his grammar of code. It has been said that code is written primarily for human beings to read and only secondarily for computers to execute, and obfuscated or poetic code is regarded as high art by many programmers. It must exemplify some of code’s salient features to them, and so it can be used to do so to a more general audience. And the cultural assumptions of code can survive from its source code into its execution and interface: witness the relief of many of Diaspora’s users than “Gender” was a free-form text field rather than a simple binary choice of “Male” or “Female”.

The final chapter on network streams provides a strong critical philosophy of social networking and other software that reduces human experience to a stream of software representations of events. After discussing what it means for a human being to be a “good stream”, Husserl’s idea of “comets” as a precedent for lifestreams and Lyotard’s idea of the stream (both of which predate the streams of the Internet by many years), Berry presents the idea of Dark Streams as a way of resisting the demands of Web 2.0. I would single this out as the most timely and invigoration section of the book and a must-read for anyone involved in producing, consuming, or critiquing networked software culture.

What doesn’t the book cover? There is no visual coding or livecoding. Berry explicitly avoids “screen essentialism”, where the output of code is concentrated on to the exclusion of its production and execution, but despite following programs from their writing through compilation to first assembly code then machine language, running software and algorithms (at the micro level) are not considered, nor (at the macro level) are the architectures of applications or of operating systems. Nor is testing except in passing. But this fits with the emphasis of the book on code as text, and the framework that it provides can be extended to these topics. Hopefully by Berry.

“The Philosophy Of Software” is particularly inspiring as a spur to further research. Each page is brimming with references in the style of the academic papers that many of the chapters were first produced as and whilst this style can be distracting at first (compared with popular science books for example) it is ultimately rewarding and gives the reader any number of fascinating leads to follow up.

What is important about “The Philosophy Of Software” is that it really is about what it claims to be about. Rather than trying to shoehorn software into an existing philosophical or political agenda it considers software as a thing in itself and finds those philosophers and philosophical ideas that best address the vitally important phenomenon of software. However much philosophy, computer science or cybercultural theory you may know this is a book that will set you thinking about software anew.

The text of this review is licenced under the Creative Commons BY-SA 3.0 Licence.

Form+Code In Design, Art and Architecture
Casey Reas, Chandler McWilliams, LUST
2010, Princeton Architectural Press
ISBN 9781568989372

Form+Code is an art computing programming primer. Rather than teaching any particular programming language it explains the technical and conceptual history of programming and its use in art. Starting with an introduction to the basic concepts of coding, instructions, form, and different ways of representing them (in sections titled “What Is Code?” and “Form And Computers”), it moves on to chapters covering “Repeat”, “Transform”, “Paramaterize”, “Visualize” and “Simulate”.

The basic concepts of programming are explained clearly with plenty of examples of code, hardware, and output. They are also related to broader art history, with examples drawn from conceptual artists such as Yoko Ono and Sol leWitt. And it’s good to see Jasia Reichardt’s pioneering work in bringing art and code together is recognised not just in the form of the Cybernetic Serendipity show at the ICA in London but her books and articles on art computing as well.

There is a little code, enough to give a flavour of what it looks like but not enough to intimidate. Listings in or examples of output from BASIC, LOGO, BEFLIX, Hypertalk and other important historical programming languages are presented. PostScript is given its due, with listings, examples of output and a discussion of its incredible impact on the graphic design industry.

Form+Code is about hardware as well as software. The Difference Engine, ENIAC, oscillioscpes, the PDP-1, arcade games machines that used vector graphics, and the Atari 2600 are all included in a historical narrative of computing and art. The book also describes and shows examples of output from printing hardware from pen plotters through laser printers to CNC and stereo lithography machines, providing a historical and conceptual grounding for thinking about the most advanced output devices currently available.

“Repeat” is explained starting with the Jacquard Loom, and the art of Bridget Riley and Andy Warhol before moving on to variations on a simple BASIC program with illustrations of its output. Packing this amount of historical, computer science and artistic information into each chapter would be overwhelming were it not for the book’s clear writing, structure and design.

“Transform” touches on Holbein’s “Ambassadors” and Victor Vasarely’s Op Art as well as the basic mathematics of folding a piece of paper. “Parameterize” has Dada, Duchamp, the Beats and Calder’s mobiles. It mentions grids without mentioning Rosalind Krauss (the book as a whole is pretty much Theory free), and explains how you use variables to produce variants on the same form.

“Visualise” and “Simulate” are almost devoid of (non-computer) art historical examples and cultural context. Harold Cohen’s AARON is illustrated, and Douglas Hofstadter, Richard Dawkins and Stephen Wolfram’s ideas are mentioned. More people should know about the wokr of Hofstadter’s FARG, and the concepts, work and writing presented are still a treasure trove of information and inspiration. But these chapters lack the art historical context of their predecessors.

The contemporary visual art computing presented is mostly in the generative art / data visualisation mold. It’s highly structured, would mostly be impossible to produce without computers, and is haunted by the possibility of being merely decorative. The only academically recognisable critical art included is one of JODI’s less threatening browser pieces. But the example of worldmapper.org in the chapter on visualisation shows how the aesthetic tools of data visualisation can be used politically. And the formal structures and creative strageties of much of the art has a quality of realism in the age of networks that is a challenge to Theory rather than a falure to illustrate it.

The success of books intended to provide a comprehensive foundation in an area of the study of art, such as “Art In Theory” or “Basic Design”, have both helped to enrich the study of art and had the unintended consequence of closing off other possible narratives. Form+Code stands to be as successful in its own area as those books were in theirs, with the same benefits and dangers. Form+Code’s ommission of virtual reality, livecoding, and other movements within art computing are understandable given its focus, but hopefully won’t lead to their neglect by students.

Could you code up any of the software art that you see in the book after reading it? No. The only code listings are historical fragments. But after reading the book you will undestand the concepts that you need both to figure out what more you need to learn in order to program such art and to understand why doing so is aesthetically and art historically worthwhile. And some source code from the book, in various programming languages, is available online.

Form+Code’s major achievement is that it presents technical, art historical and technical historical information in such a way that it complements each other and builds a bigger picture that demonstrates the wider relevance and further potential of art computing programming. Having read it, you’ll know more and you’ll both want to and be able to learn how to do more. It’s clearly laid out, packed full of illustrations, occasional code fragments, plenty of references to sources for further investigation, and even has a good index. It really is a foundation course in a book, providing a sound basis for further learning or research.

If you teach art computing, and if you are teaching art, graphic design, textiles, fashion or architecture then you are teaching art computing to a greater or lesser degree, then Form+Code is a perfect primer for the conceptual, historical, and cultural side of computing and art computing. Outside of education, if you are involved in art, computing, or are a non-programmer computer-using artist Form+Code provides a good grounding in the concepts used in programming for art computing.

Form+Code serves as a complete introduction to the conventional history, concepts and practice of visual art computing. It presents that information in the context of the broader history of art and design. And it provides enou