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.

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.

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.

MIT Press has just published Processing: a programming handbook for visual designers and artists by myself and Ben Fry. The book is the result of over two years of work on the publication and four more years of research.

The book is an introduction to the ideas of computer programming within the context of the visual arts. It targets an audience of computer-savvy individuals who are interested in creating interactive and visual work through writing software but have little or no prior experience. It is the result of six years of software development and teaching experience. The ideas presented have been continually tested in the classrooms, computer labs, and basements of universities, art and design schools, and arts institutions.

The majority of the book is divided into tutorial units discussing specific elements of software and how they relate to the arts. These units introduce the syntax and concepts of software such as variables, functions, and object-oriented programming. They cover topics such as photography and drawing in relation to software. These units feature many short, prototypical example programs with related images and explanation. More advanced professional projects from diverse domains including animation, performance, and typography are discussed in interviews with their creators. The extension sections present concise introductions to further domains of exploration including computer vision, sound, and electronics.

Essays by Alexander R. Galloway, Golan Levin, R. Luke DuBois, Simon Greenwold, Francis Li, and Hernando Barragan.

Interviews with Jared Tarbell, Martin Wattenberg, James Paterson, Erik van Blockland, Ed Burton, Josh On, Juerg Lehni, Auriea Harvey and Michael Samyn, Mathew Cullen and Grady Hall, Bob Sabiston, Jennifer Steinkamp, Ruth Jarman and Joseph Gerhardt, Sue Costabile, Chris Csikszentmihalyi, Golan Levin and Zachary Lieberman, and Mark Hansen.

There are sample chapters and program examples on the Processing website.