On its own, code is a painful way to draw. I remember being puzzled when learning LOGO on the Apple II as a kid. I was confused, and my drawings looked like crap. I didn’t know who this turtle was, or why it seemed to need explicit instructions to draw things that looked like nothing – or why my over-talented colleagues had made elaborate pictures of houses when I couldn’t seem to do anything. But I wasn’t pleased.

The answer, of course, was that simply drawing by coordinates isn’t any fun. It’s only when you can add variability to a drawing, and start to take advantage of the computer’s ability to form generative structures, that computers become useful, that they do something you can’t with a pen and paper. This entry and the next one will start to introduce the absolute basic elements that make that possible.

Reading: See chapter four of Dan Shiffman’s book Learning Processing for more detail on variables, and review chapter one for color.

Continue reading »

We’re beginning in class at Parsons with chapters 1-2 of Dan Shiffman’s Learning Processing. The best thing about these chapters is the order. Chapter 1 can be accomplished with a pencil and grid paper, no computer required. That’s a habit to get into early – whenever you’re stuck or just need to think outside the code onscreen, sketching is a must. Chapter 2 you can fairly well skim as you’re getting started, but the idea is to understand what Processing is, and to load it up for the first time.

Once you have Processing loaded, let’s start working with code. These code snippets were an attempt by me to apply thoughtless reduction. The examples in the program are very good, but they can actually be too artful. I wanted to reduce to only the code that was needed to understand a concept.

First, as in Design By Numbers, it’s possible to set up a canvas (“paper”) and begin drawing using just two lines of code.

#1: Get something on the screen, right away.

size(400,400);
line(100,100,200,200);

Note the use of the semicolon as a line break, parentheses to “give” these commands values with which to work, and commas to separate those values. To me, this is actually easier to read than the approach used by Design By Numbers, which didn’t have these separators. otherwise its like looking at text with no punctuation or capitalization all jumbled together dont you agree Continue reading »

While John Maeda focuses on elegant “Laws of Simplicity,” my focus here will be on my emerging Laws of Stupidity. These are reflections both on the dangers of my own stupidity, and the potential ability to harness the powers of stupidity to conquer any task.

Law 1: Get Stupid.

Maeda’s First Law regards “thoughtful reduction.” That’s a helpful, subtle, and rich metaphor for what you have to do to provide a solution that balances flexibility with simplicity – in other words, your final design.

As a programmer, and sometimes a pretty clumsy programmer, I believe the first step should be thoughtless reduction.

Reduce everything to the point that you think it’s actually pretty stupid. Continue reading »

Because I believe some of the thought DNA of John Maeda is embedded in Processing (and, for that matter, Ben Fry, Casey Reas, and someday – you), I think it’s worth reflecting on some of those thought patterns and not exclusively the tool itself.

There’s no better place to start than John Maeda’s Laws of Simplicity, and no better law for a blog on teaching and learning Processing than this one:

Law 4: Learn.
Knowledge makes everything simpler.

[Read the excerpt]

The crux of Maeda’s point is the converse: the lack of knowledge makes everything really bloody difficult. Turn a screwdriver the wrong way, and the process becomes mysterious and painful. Continue reading »

Before there was Processing, there was Design By Numbers. Created by the Aesthetics and Computation Group at the MIT Media Library, and part of a project initiated by John Maeda, the mission was not to create a particular technology or even teach technology, but to teach computational thought as a window into design and art.

Design by Numbers Site [note that the project is largely inactive, and some of the documentation links are sadly broken]

Design By Numbers was created for visual designers and artists as an introduction to computational design. It is the result of a continuing endeavor by Professor John Maeda to teach the “idea” of computation to designers and artists. It is his belief that the quality of media art and design can only improve through establishing educational infrastructure in arts and technology schools that create strong, cross-disciplinary individuals.

DBN is both a programming environment and language. The environment provides a unified space for writing and running programs and the language introduces the basic ideas of computer programming within the context of drawing. Visual elements such as dot, line, and field are combined with the computational ideas of variables and conditional statements to generate images.

Continue reading »