Form+Code in Design, Art, and Architecture is now officially published:

Form+Code in Design, Art, and Architecture
Casey Reas, Chandler McWilliams, LUST
Princeton Architectural Press
ISBN 9781568989372
7 x 8.5 inches (17.8 x 21.6 cm)
Paperback, 176 pages

Chandler and I started the project at the beginning of the summer 2007 with a workshop titled “Form + Code” at the Telic Arts Exchange in Los Angeles (19 July 2007 from 7:00 pm to 11:00 pm). The Dutch design studio LUST was folded in to the team in November of the same year. We developed the book with Chandler and myself primarily curating the images and developing the text and LUST leading the visual communication and layout exploration. The project was taken to some extreme variations as we explored the material. The primary consideration that we wanted the book to be as affordable and widely available as possible drove many of the decisions including the format (a small paperback) and the publisher (Princeton Architectural Press).

The book grew out of two overlapping desires. First, Chandler and I spend much of our lives working with UCLA undergraduates in the Department of Design Media Arts and we’re continuously developing lectures and examples for them. Form+Code was developed to give them a broad understanding of how code is used within the visual arts. Second, after completing Processing: a Programming Handbook for Visual Designers and Artists, I had the desire to make a book about the same topic, but from a totally different perspective. That book taught the reader how to program, but it didn’t discuss why it’s an interesting thing for a designer or artist to consider. Form+Code is a non-technical introduction, while Processing: A Programming Handbook is a rigorous technical foundation.

Here’s some text from the formal book proposal to Princeton Architectural Press completed in August 2008:

Form+Code discusses the role of software in visual design, art, and architecture. It hopes to generate interest in creating visual and spatial form with software across diverse fields by focusing on the history, theory, and practice of software in the arts. The book is about one quarter text and three quarters images. It is organized around two parallel narratives: one told through images and captions, and the other through essays with related diagrams and images. This allows the book to be read cover-to-cover or leisurely looked through as a source of inspiration.

The book is divided into seven chapters: What is Code?, Computers and Form, Repetition, Transformation, Parameters, Visualization, and Simulation. The first two chapters set the foundation for the rest of the book by discussing the history of the computer in the arts and how software is used to create form. The five themes of repetition, transformation, parameters, visualization, and simulation are deeply linked to code. Each of these sections begin with an essay to define the territory, continues with images and captions, and concludes with code examples written in a few designer-friendly programming language such as Processing and ActionScript (the code won’t be included in the book, but will be available from the URL www.formandcode.com). Form+Code is not a programming tutorial; its goal is to inspire though the discussion of themes and projects.

…

Unlike many other books, the visual design of Form+Code is a close collaboration between the primary text authors (Casey Reas, Chandler McWilliams) and the primary visual authors (LUST). The visual layout will be almost conventional, but will include details that illustrate the marriage of code and form. These details will further convey the primary content of the book.

We are patterning the structure of Form+Code closely on Ellen Lupton’s Thinking with Type. We feel this book is a superb synthesis of text and image; it’s the right amount of content to provide a solid introduction to its subject, while brief enough to make it manageable and affordable. We strive to reach this balance and to appeal to a similar audience of students, educators, and professionals. We’re also highly influenced by Processing: A Programming Handbook for Visual Artists and Designers, written by Casey Reas and Ben Fry. In a way, Form+Code, is a prequel to this book. The Processing book is a 736 page textbook primarily printed in black and white, but its subject matter is highly visual. Form+Code presents much of the background research for the Processing book in a full-color and image-heavy presentation.

There could be many books written in relation to the topics of form and code. The Form+Code book is written for students, educators, and professionals in the fields of design, art, and architecture. It’s intended to provide a foundation for and/or augment academic courses related to “digital design”, “interactive media”, “computational design”, “media art”, “introduction to computer graphics” “introduction to programming“, and other related areas. The book is also meant to be appealing and appropriate for people outside of academic institutions, but involved in the above mentioned fields. It is equally appropriate for non-specialists who are interested in these areas. The book is very visual, but the text is rigorously researched and provides clear context for the images. It is not a reference book or a technical manual; it is an introduction to a deep topic and therefore will be engaging to read. All content is framed within the context of the arts. The book is intended as a foundation text and there are no prerequisites.

To learn more about the book, please visit the website http://formandcode.com.

Clad, a collaboration with davidclovers, will be exhibited at the 12th International Architecture Biennale in Venice, Italy. Clad is part of the Hong Kong Pavillion’s exhibition titled Quotidian Architectures located at the Arsenale, Campo dello Tana, Castello 2126. Clad is a group of four glass fiber reinforced concrete (GFRC) prototypes for Lunar House. The exhibition is open from 29 August to 21 November 2010.

Chandler and I are happy to announce a book launch party for Form+Code in Design, Art, and Architecture at Telic Arts Exchange in Los Angeles on Saturday, 4 September from 5 – 7pm. Please join us. We’ll have a toast at 6:30 to thank the many book contributors who’ll be there. Champagne and snacks will be served and we’ll have copies of the book on hand. Directions to Telic (951 Chung King Road Los Angeles, CA 90012) are available on their website.

After spending about quadruple the time we allotted for it, the formandcode.com website for our forthcoming book Form+Code in Design, Art, and Architecture is online. The site includes photos of the book and the code for each chapter’s examples (the code isn’t printed in the book), as well as the Contents, Bibliography, Links to people featured in the book, and more. Here’s the official description for the book:

Once the exclusive domain of programmers, code is now being used by a new generation of designers, artists, and architects eager to explore how software can enable innovative ways of generating form and translating ideas. Form+Code in Design, Art, and Architecture offers an in-depth look at the use of software in a wide range of creative disciplines. This visually stimulating survey introduces readers to over 250 significant works and undertakings of the past 60 years in the fields of fine and applied art, architecture, industrial design, digital fabrication, visual cinema, photography, typography, interactive media, gaming, artificial intelligence (AI), artificial life (a-life), and graphic design, including data mapping and visualizations, and all forms of new media and expression.

The book will be available on 1 September 2010 and is currently available for pre-order at Amazon, etc.

Adam Lerner’s Mixed Taste format (”Tag Team Lectures on Unrelated Topics”) from the MCA Denver was brought to Anderson Ranch for the annual National Council Celebration. I gave a twenty-minute presentation on Data Visualization (based on the Visualization chapter in Form+Code) which was preceded by an amazing presentation on Fly Tying. The question and answer session that followed the presentations was a game where the audience made connections between the topics.

On July 15th, I participated in a one-day conference at the University of Southern California (USC) on the subject of Critical Code Studies. (The area of Critical Code Studies is emerging and it’s currently difficult to distinguish it precisely from the area of Software Studies.)  I made a presentation with Nick Montford and Jeremy Douglass on the subject of a one-line BASIC program for the Commodore 64:

10 PRINT CHR$(205.5+RND(1)); : GOTO 10

The schedule follows:

9-9:20: Welcome
Mark C. Marino, USC

9:25-10:25: Panel 1
Jeremy Douglass, UCSD
Liz Losh, UCI
Marisa Plumb

10:30-11:50: Panel 2
Federica Frabetti, Oxford Brookes University
Tara McPherson, USC
Benjamin Bratton, UCSD
Craig Dietrich, USC

1-2:20: Panel 3
John Williams, Yale University
Aaron Reed, UCSC
Max Feinstein, USC
Brett Stalbaum, UCSD

2:25-3:40: Panel 4
Dave Shepard, UCLA
Evan Buswell, Portland State University
10-Print by Nick Montfort (MIT), Casey Reas (UCLA), and Jeremy Douglass (UCSD)

3:45-4:25: Computer Science Panel
Stephanie August, LMU
Paul Rosenbloom, USC

4:30: Keynote
Wendy Chun, Brown University

I’m happy to announce the publication of my latest book written with Ben:

Getting Started with Processing
Casey Reas, Ben Fry
O’Reilly Media / Make
Print ISBN  978-1-4493-7980-3
Ebook ISBN  978-1-4493-7981-0
5.5 x 8.5 inches
Paperback, 208 pages

This slim volume was written as a softer introduction to programming than our book with MIT Press, Processing: A Programming Handbook for Visual Designers and Artists. In contrast, it’s more casual and affordable and focuses specifically on Processing. At the request of the O’Reilly, we answered a series of questions to help them promote the book. I think they are the most concise way to explain why we wrote the book:

What made you write the book?

To make learning computer programming easier and more enjoyable. This book is for a different audience than the overwhelming majority of programming books. We promote a different approach that emphasizes making and doing and creativity. We introduce programming by emphasizing image making, rather than manipulating numbers and text.

Why is your book especially important now?

Software is one of the most important forces defining our future: culturally, socially, politically. We focus on the cultural component. This book integrates learning how to program with the visual arts. The promotion quotes on the inside front cover of the books sums this up, particularly the quote from John Maeda:

“Making a computer program used to be as easy as turning it on and typing one or two lines of code to get it to say, ‘Hello.’ Now it takes a 500+-page manual and an entire village. Not anymore. This little book by Ben and Casey gets you computationally drawing lines, triangles, and circles within minutes of clicking the ‘download’ button. They’ve made making computer programs humanly and humanely possible again — and that’s no small feat.”
John Maeda, President of Rhode Island School of Design

What is the single most important thing readers of your book will be able to do after reading your book

To write their own programs. This changes the relationship between an individual to her computer. She is now a creator, producer, and maker. She starts to become literate in a new way.

Who is your intended audience?

This book is for the hobbyists, tinkerers, and makers, but about it’s about software, rather and electronics and construction. It assumes no prior knowledge of programming, but it does assume a basic understanding of using computers and graphics software for drawing. The audience ranges from children to hobbyists to professionals – people interested in getting started programming through making images. It’s a perfect book for workshops because it covers the basics quickly and is inexpensive. It’s a gift for the children, nephews, and nieces of programers. It’s for people who loved Logo as a child and want to pass on that experience to the next generation.

How important is the subject matter of your book? What do you think is on the horizon for your readers?

This book is a gateway to learning more about programming. It’s intended to get people excited. It can be followed with a number of other books and classes.

Getting Started with Processing related to other O’Reilly titles:

Visualizing Data by Ben Fry
Programming Interactivity by Joshua Noble
Making Things Talk by Tom Igoe
Getting Started with Arduino by Massimo Banzi

Could you send us a list of 5-10 tips, tricks, and/or best practices?

We’ve compiled five short programs from Getting Started with Processing. Download the Processing software from http://processing.org or run them online at http://sketch.processing.org. Cut and paste one program at time into the text box and press the play button to run.

Example 3-17: Draw with Transparency

size(600, 400);
noStroke();
smooth();
background(204, 226, 225);     // Light blue color
fill(255, 0, 0, 160);          // Red color
ellipse(232, 182, 400, 400);   // Red circle
fill(0, 255, 0, 160);          // Green color
ellipse(328, 84, 400, 400);    // Green circle
fill(0, 0, 255, 160);          // Blue color
ellipse(368, 218, 400, 400);   // Blue circle

Example 4-12: Pins and Lines

size(600, 400);
background(0);
smooth();
fill(255);
stroke(102);
for (int y = 20; y <= height-20; y += 10) {
  for (int x = 20; x <= width-20; x += 10) {
    ellipse(x, y, 4, 4);
    // Draw a line to the center of the display
    line(x, y, 300, 200);
  }
}

Example 5-9: Smooth Lines with Easing

float x;
float y;
float px;
float py;
float easing = 0.05;

void setup() {
  size(600, 400);
  smooth();
  stroke(0, 102);
}

void draw() {
  float targetX = mouseX;
  x += (targetX - x) * easing;
  float targetY = mouseY;
  y += (targetY - y) * easing;
  float weight = dist(x, y, px, py);
  strokeWeight(weight);
  line(x, y, px, py);
  py = y;
  px = x;
}

Example 7-9: Move Shapes Randomly

float speed = 2.5;
int diameter = 60;
float x;
float y;

void setup() {
  size(600, 400);
  smooth();
  x = width/2;
  y = height/2;
}

void draw() {
  x += random(-speed, speed);
  y += random(-speed, speed);
  ellipse(x, y, diameter, diameter);
}

Example 10-9: Track Mouse Movements

int num = 60;
int x[] = new int[num];
int y[] = new int[num];

void setup() {
  size(600, 400);
  smooth();
  noStroke();
}

void draw() {
  background(0);
  // Copy array values from back to front
  for (int i = x.length-1; i > 0; i--) {
    x[i] = x[i-1];
    y[i] = y[i-1];
  }
  x[0] = mouseX; // Set the first element
  y[0] = mouseY; // Set the first element
  for (int i = 0; i < x.length; i++) {
    fill(i * 4);
    ellipse(x[i], y[i], 40, 40);
  }
}

This is just the beginning, Getting Started with Processing has over 120 example programs.

We launched a new version of the Processing Discourse forum, now called the Discussion, a few days ago. This was a part of re-organizing the Processing reference and community materials and there’s more to come. The forum is a change that we’re extremely excited about and it fits into the plans for the new Processing wiki, the upcoming Processing blog, and recent move to Google Code. We see these four pieces fitting together as follows:

Processing Discussion Forum
The forum is the place where things begin and discussions are held. It’s a place for the exchange of ideas and knowledge. We’re excited to start fresh (a little late spring cleaning) so we’re not porting over the previous content or user accounts. The previous two Processing forums (one for the software from beta to 1.0 and one for the alpha software) will be archived as HTML pages and will remain available. The Processing community has held some amazing discussions over the years and we want that knowledge to remain publicly available.

Processing Wiki
The wiki holds the technical documentation and community-generated code examples and tutorials. The best discussions from the forum will hopefully be edited and documented on the wiki as examples and tutorials for easy reference and updates.

Processing Blog
The blog is for announcements from the Processing developers. It’s a one-way communication channel used for new releases and changes to the software. The announcements that used to be made through the Processing Discourse Forum will now go through the blog.

Processing on Google Code
This is the active resource for the SVN code repository, source browsing, and bug tracking. All bugs reports and suggestions for the software will now be handled through this site.

The main Processing website will remain the place for the exhibition, code reference, tutorials, and the software download. The main website is the public face of the project, while the work and innovation happens on the forum and wiki.

The new Processing wiki is alive and kicking. It complements the main site, processing.org. The wiki includes code documentation, reference material, code samples, and more. Please have a look around and consider contributing. It includes technical information, code examples, tutorials, comparisons between Processing and other languages, and interviews with Processors. Much of the wiki was ported over from Processing Hacks, an initiative started by Tom Carden and Karsten Schmidt.

Congratulations to the UCLA Design Media Arts class of 2010! Graduation was Saturday 12 June from 4-6pm, followed by a reception for the I.R.L. senior show in the EDA. I can’t wait to see the photos of myself and all of the MFA recipients jumping in front of the Serra sculpture a la Halsman.