*new* Teaching work up at: archCUA.tumblr.com

Here’s a video of it in use:

As I said, this is not new technology, but I think its introduction into the Architectural Design Market is nonetheless significant. As we know, the Architectural Design Market has been incredibly slow one to adopt new technology - especially when compared to most other design professionals - and in my mind any technology that has the potential to provide additional (and hopefully meaningful) design feedback is welcome in my view.

All I can say is that the plugin is incredibly easy, and poised to change many things surrounding the field of architecture. It’s absolutely brilliant. While there are other products on the market that work in a very similar way (ie. Generative Components), none that I’m aware of are so simple or packaged with such a versatile and intuitive modeling package. Grasshopper plugs directly into Rhino and uses all familiar Rhino commands, so there is very little learning curve. Really, really, really simple and powerful plugin. Very exciting.

Since Sunday, I’ve been working on my first Grasshopper definition, which was inspired by a number of things, but primarily:

• The need to laser-cut things in a way that was not extremely tedious and annoying
• A Rhinoscript I was working on last year but never finished (but had less control)
• An earlier, and similar in function (but not in implementation) definition by Andrew Payne of LIFT Architects (and fellow Creative Commons user).

From here...

...to here in about 30 minutes.

(The blue tape is a result of a mistype for the material thickness…painter’s tape is not a structural material…)

Here’s the Definition (you can also find it in the experiments section:

Waffle House v1.0

And the Tutorial (apologies for the poor quality):

Waffle House v1.0 Tutorial from Benjamin G Callam on Vimeo.

I’m sorry can you please repeat the question?

The Curtains were hung from the same track that the ballroom dividers use (those nasty doors used for conferences, etc.) and a pipe was inserted in the bottom of the curtain so that it would splay out at the bottom. To further sculpt the shape, fishing wire was sewn through the curtain about 2/3 the way up and buttons (button!) were used to constrain the shape of the curtains (to restrict the width of the wire). Since the room needed to be converted quickly for the reception following the ceremony, the staff needed to only remove the piping at the bottom of the curtain to tie them back during the turnover.

The last piece that might be of interest was a “computational design” written in Processing that served as a backdrop for the ceremony. The 90″ x 240″ design was based off “Sands of Time” by Jared Tarbell which was adapted for the ceremony. One of the technical challenges here was to get processing to write out such an enormous file (each was about 400 megs) while still being able to view the progression of the algorithm in realtime. Here are a few variations of the designs (we used #3), which was split down the center for printing.

Variation #1

Variation #2

Variation #3

Variation #4

Variation #5

Variation #6

Variation #7

Speaking of printing, special thanks to Jonathan Healey and Colleen Gove for their help with the last minute printing - it took about 2 hours for to print each banner. I hope I can be as helpful for their wedding (congratulations guys!)

In Courtney’s Arch448E course last spring (at Maryland) I developed a number or Processing Sketches which made use of a live video feed as a generative device for on screen graphics. These made use of a couple techniques. One technique was sequential frame differencing where each frame (or series of frames) is evaluated against previous frames to determine where pixels have changed. This technique is especially good for situations where light and/or background conditions will change. This was used in my “Studioscapes” sketch, where the live feedback is used to display what is essentially a three dimensional graph of the motion. This became interesting when students began to understand that their motion produced the onscreen effects, which created what I thought was an interesting feedback loop, and often led to complex human patterns of movement. As you can see from the video compilation, the graphics respond not only to the current frame, but decay (logarithmically) over time as a short history of movement.

Studioscape from Benjamin G Callam on Vimeo. 

An alternative technique of static frame differencing worked essentially like a green screen. The program takes an image of the static scene (the background) then checks every subsequent frame for pixel variations from the original. This approach proved difficult primarily because of technical difficulties, but otherwise should be a very easy way to detect onscreen presence (in this case, people). The difficulties arose because the cameras I had at my disposal would automatically adjust their sensitivity as light conditions changed. So for example if someone walked in front of the camera with a white shirt, the camera would adjust and suddenly every pixel has changed (it also didn’t help that I was exhibiting this at dusk)…but at any rate it was frustrating. I was trying this with the built-in iSight in my Macbook Pro, and was not able to find a way to “turn off” the brightness adjustment. Anyhow, for the Particle People project I adapted the Traer particle simulation class to attract to changes found by the frame differencing. This also encouraged strange behavior by the participants at the exhibition (I unfortunately don’t have any footage of) which was heavily influenced by the particle system. 

The feedback loop (in both projects) caused the participants to reevaluate (consciously or not) their local spatial environment with regard to both “real” space and the implied space of the digital environment. In both cases, I was quite surprised by the interest people took in this hybrid environment particularly how common social interactions were transformed by the hybrid environment. Taken as a pair (again unfortunately no footage for the second) this was quite evident.

Virtual Trajectories:

This project explored the virtual proximity of image on the internet. The sketch in this case would visit a news site’s homepage, then based on the available links, randomly select one as the next node to visit. With each visit to a node, the largest image on the page was downloaded and compiled into a super graphic which was the constantly evolving image displayed to the viewer. The juxtaposition of virtually adjacent images (meaning within just a click or two of each other) display were often surprising (if not jarring) and was intended to encourage the viewer to question ideas of image proximity in our contemporary environment. News sites were chosen because their content is constantly changing based on current events (or you might assume), so as the sketch traversed the site, shifts could be detected in the value a particular image might have for that particular news media based on prevalence of image. This sketch was particular challenging for me to write due to my lack of experience with regular expressions, and it was not until I had completed the sketch that I became aware of a preexisting Processing library specifically for link and image traversal. I have not posted the source here yet because I intend to revisit this work and fine-tune the algorithm based on these libraries.

All images compiled from CNN.com

Screen Capture 1

Screen Capture 2

Screen Capture 3

Roto Raster:

A (very) simple script that takes an image and translates it into rectangles (but could easily be anything) based on brightness and outputs the translation as a pdf or DXF. It was created for use in a project I am working on with 3FoldStudio. It’s based on Explode by Daniel Shiffman (check his new book), and was created for easy translation to vector files for a laser cutter,CNC, etc. The same could be done in a number of programs, but hopefully this one will eventually grow an interface to allow for easy web-use. This one could be easily modified to use color, different shapes, etc.

Image before

Image after vectorization

Project #1 - LINE.

Line

What is a line? The technical definition of line differs greatly from the way line is often described in an architectural environment. This project explored these variations using several types of media. The final was print and ink on mylar.

playful. rigorous. beautiful. animated.

Hopefully he will be updating frequently at http://www.butterfly.ie/
 

But why not do it yourself?

Why not create your own virtual machine on the EC2 (what renderrocket is using)? Turns out, installing Ubuntu or Fedora (Linux) - complete with a X11 VNC terminal (ie. a GUI not command line) - is much easier that I could have imagined. And to take it one step further, I also found this tutorial to get Windows Server 2003 to run on EC2 as well (and OSX is hinted at but not explained due to licensing issues)…including automatic conversion of VMware images (like my XP image…).Lets just hope openGL or DirectX can be emulated as well.

 And guess what? Bezos likes it.

Although its hard to judge the performance of Windows/OSX (via EC2) vs. renderrocket (non linux images run through an emulator) the people leading this charge appear to be optimistic about performance optimization…and at the least one of these solutions should allow my laptop to travel freely (home to my wife) without pausing render sessions en route (and no more rendering on Metro). 

And if you haven’t read the Wired interview, its highly recommended…this is merely one application of the ridiculously cheap AWS which we will surely see more of as people migrate to smaller and more mobile computing devices (iPhone).

w00t to that.

“The reasonable man adapts himself to the world; the unreasonable one persists in trying to adapt the world to himself. Therefore all progress depends on the unreasonable man.”

- George Bernard Shaw, quoted in the Lexington Herald-Leader

more from abstractmachine

And to be clear, I’m not just throwing around my favorite recurring vocabulary fetish with “obfuscate” - there is a rich tradition of code obfuscation especially rooted in the Perl - the language that really put the fun back in text parsing (kidding)…which is how I came to return to the world of regex’s. Don’t get me wrong, regular expressions are fantastically interesting (there is a very geometric nature to the construction and execution of the expressions), but not exactly the nicest thing to reteach yourself on a sunny Wednesday afternoon in May.

I’m using Java’s regex library (not too bad…) within Processing to parse news websites for photos and links. This has been frustrating for two primary reasons: 1) The syntax can be incredibly confusing when you are not used to it and 2) I all too aware that the 15 or so smaller expressions I’ve had to create could be packed into a single line of code probably about 30 characters long by someone who actually knew what they were doing. Not to mention there is probably a Google API to do exactly what I am doing that wouldn’t require 4 different classes to handle the 4 media sites slight variations in formatting. Behold the following remedial atrocities:

• “href\s*=\s*”([^mov|jpg|gif|pdf|xml|rss|css][^"]*?)”
• I think this one captures my feelings: “\w?^([^http].*)\w?”
• CNN.com images: “src\s*=\s*”(http[^"\s]*(jpg|jpeg))”

Anyhow…the purpose of all this trouble was to allow a pseudo-random traversal of the sites, while also allowing me to grab photos and captions along the way. If the networks don’t permanently block me for the number of network bursts my debugging has unleashed which I’m sure look like really lame DOS attacks, I should have a pretty cool piece by the end of it (tomorrow!!).

In the meantime here is this beautiful piece of obfuscation:

#!/usr/bin/perl
$_[$.++]=chr for($_=(–$|.$|-$|.$|-$|)-$|—$|—$|-
$|)..$_-(-$|-$|.-(-$|-$|-$|-$|-$|)),($|-(-$|).–$|),
(–$|.$|-$|);$,=$_[-$|-$|];$\=$_[-$|];print$_[$_=--
$|.$|---$|].$_[$_-=-($|.$|)].$_[$_-=$|-(-$|)].$_[$_-
(-$|)],$_[--$|].$_[$_-=-($|---$|-$|-$|-$|-$|)].$_[$_
-=$|---$|---$|-$|].$_[$_-=-$|-$|-$|-$|-$|].$_[$_-=$|.
-(-$|-$|)].$_[$_-=-(-$|-$|-$|)].$_[$_-=-($|.$|-(-$|-
$|))],$_[$_-=-(-$|-$|)].$_[$_-=$|.$|].$_[$_-=-($|.$|
-(-$|-$|))].$_[$_-=-(-$|-$|-$|-$|-$|-$|)],$_[$_-=-(
-$|-$|-$|-$|)].$_[$_=--$|].$_[$_-=-($|---(-$|-$|))]
.$_[$_-(-$|-$|-$|-$|-$|-$|-$|-$|)].$_[$_-=(-$|-$|)].
$_[$|.($_-(-$|-$|-$|))];

courtesy: http://www.perlmonks.org/

Which prints: “just another perl hacker”

Creativity is an inborn capacity for thinking differently than most, seeing differently, and making connections and perceiving relationships others miss. But most importantly, it is the ability to then extrapolate contextually useful ways of employing that data: to create something that meets a specific challenge.

An M.Arch is a professional degree, and I really believe it should be treated as such. That does not imply that every school project has to be “realistic” (whatever that is), but that each project should explore at least one challenge critically. As Rutledge says, design begins with DATA (and no not Filemaker). Data means research. It means a deep understanding of the problem at hand, that is researching information that will drive a design (see the paragraph on constraints). This is not taking a goddamn Mondrian painting, using it as an architectural plan and justifying it by reminding people that Mondrian painted it and that he was talented. This (bs) is (very bad) formalism. Art can be formal. Architecture should not - unless its not about a context or building. Then I would argue its art. This is a very fine line, especially in architecture.

And there is definitely a place for formalism - it can be provocative, abstract, inspirational. But it is different. As Rutledge says:

Creativity is technical and analytical, not expressive (as in self-expression). It is a filter through which perception and output pass, not a receptor or an infusion (as in the case of inspiration). Creativity may require or be enhanced by inspiration, but the two are distinct forces.

Creativity then is not self-serving, inherently contextual - and therefore a perfect model for responsible architecture. The way designers train this filter (the synthesizer) is by critique.

Or perhaps as an equation?

• algorithms are not always based on solution strategies concieved entirely in the human mind 19
• unlike inventions, discoveries are not conceived or controlled by the human mind 19
• an algorithm can describe either the way a problem is to be addressed by a human or by a computer
  • algorithm is a rationalized version of human thinking
  • algorithm is a linguistic expression fitted for the computer 17
• rather than using algorithms to copy, simulate or replace manual methods of design (while desireable in some cases) instead can be studied as methodologies that operate in ways similar, parallel, or complementary to the human mind
  • can lead to new concepts, ideas, etc that thereafter effect the way designers think
• During the transfer of actions it is possible for a discrepancy to occur between the original intention and the actual design 20
• theoretically the ownership of an idea is intrinsically connected to the predictability of its outcome…that is intellectual control
• computational arrangement of formal rules that describe define, and formulate a certain style can produce permutation of possible formal expressions for that style 21
• as with mathematician, the invention or discovery of a mathematical formula does not necessitate the mathematicians knowledge of all the possible uses, repercussions, or consequences of the formula 22
  • or just by changing parameters
• is intention necessary in design? is it a human privilidge only?

blink and intuition

This project took way too long - not because of the programming, but because my understanding of differential equations is miserable. Still learned a lot though, and Processing is an amazing framework. The highlight (w00t!) was the recursive way that the the color trails are handled. Gotta love recursion…and a real programming language.

Actually it was quite shocking to dive back into Java only to realize the extent that in a few short months VBS had corrupted my programming intuition. Serious semicolon deficiency. Conditionals mistakenly assigning value (if(x=4)). Makes for some stupidly annoying debugging.

2D sketch here (the original project): Lorenz Attractor 2D

3D sketch here (much cooler): Lorenz Attractor 3D

From the “About” page:

This site began as a means to document an independent study course that I created at the University of Maryland school of Architecture to document my interest in architecture related scripting. That specific course has concluded, but as I had hoped, that initial study provided me with the catalyst I needed to jump start an ongoing experiments computational design.

As an undergraduate student I studied computer science where senior year I stumbled on hacker/writer/painter Paul Graham’s blog. The following from Graham’s essay “Hackers and Painters” resonated strongly with me … at the time I had completed the required computer science coursework for my degree and was exploring courses in sculpture and philosophy as electives.

I’ve never liked the term “computer science.” The main reason I don’t like it is that there’s no such thing. Computer science is a grab bag of tenuously related areas thrown together by an accident of history, like Yugoslavia. At one end you have people who are really mathematicians, but call what they’re doing computer science so they can get DARPA grants. In the middle you have people working on something like the natural history of computers– studying the behavior of algorithms for routing data through networks, for example. And then at the other extreme you have the hackers, who are trying to write interesting software, and for whom computers are just a medium of expression, as concrete is for architects or paint for painters. It’s as if mathematicians, physicists, and architects all had to be in the same department.

Interestingly, Graham, who made his fortune in 1998 when Yahoo acquired some web-based software he had written, has an MFA in painting. He also generalizes hackers as architects. Go figure.

Obviously, I identify with the “hacker”. I have always had trouble studying technical subjects if I can’t see the immediate application of a concept. I most definitely was not the mathematician, nor was I the physicist - although I did start school in engineering. I wanted to build ideas (now), not measure the velocity of the steel ball rolling off the table.

As an alternative, computer science allowed me to design virtual interactions in real time that were (at least marginally) useful. Sculpture was physical design. Philosophy was intellectual. One of the greatest benefits of a liberal arts education is that you can study in a multitude of ways simultaneously…but its really difficult to find someone to pay you to do all three. You have to call it something else.

Ironically, now in architecture school, we present images of potentially physical things that may or may not be useful…and we pay to do it. Apparently this is called progress.

Truthfully though, there is amazing progress to be had. As Graham suggests, hacking is about design and I would argue that regardless of medium, all design is inherently technological. Architecture is a codification of material and experiential interactions, which even at the smallest scale can be an overwhelming amount of information to consider for a design. Given the scope and nature of architectural design problems, properly leveraged computation can deliver powerful solutions. Even experimental architect Greg Lynn, who Terzidis would have undoubtedly considered a “NURBS Mongerer” a just few years back, now offers this powerful observation about the roll of computational tools in architectural design (from Programming Cultures AD, August 2006):

“Architecture is different to many other design fields because 1) practically it is about the assembly of a large constellation of elements into a whole that has an interior and and exterior that are continuous in terms of design. and 2) its design history is based on the continuity and hierarchy between interior and exterior and parts and whole, thus the discourse of facades, detailing, modularity, proportion, symmetry, and so on … The relationship between parts and whole is essential to the evaluation of quality, meaning and experience of any architectural design.

Parametric tools - that is, tools that blend the hierarchy of parts and whole - are extremely powerful for an architects because of this. Unfortunately, the initial response to parametrics was an abdication of the problem of the design of the whole in favour of the programming of the component. The use of parametric software is all about the design task shifting from either top-down or bottom-up to the territory of parts-to-whole fusion. I shy away from words like ‘feedback’ and ’synergy’ between parts and whole because so far the experimental architects have just jumped from top-down determination of parts to bottom up determination of wholes … I find this theoretically naive and it avoids the most interesting thing about parametrics, and that is the ability to fuse the hierarchy of parts and whole to produce a deeply modulated whole as well as infinitesimal variation among parts.”

After all, design is fundamentally about relationships. The richer the relationship, the richer the product. Rich relationships create synergy (kindly ignore the cliche) - that is, a whole greater than the sum of parts. Hacking, and more generally the computer should hardly represent the looming antichrist that critics of digital design claim, but rather an infinitely flexible suite of tremendously powerful design tools. Just as Graham says, the computer is a medium of expression, and truely powerful one at that. In a profession such as architecture where the design medium is typically a means rather than an end, this is especially important.

A design medium is also never passive. Just as one may express ideas differently with a pencil than with a pen, digital design is multifaceted. BIM, NURBS, animation, and hacking methodologies to name a few, like more traditional design methods,each must be understood in terms of their respective qualities if architects are to truly leverage computation for betterment of design and physical making. This is already happening, but we have barely seen the tip of the iceberg.

Toward this goal I intend to explore a design methodology the only way I know how: through experimentation. On this site you will find the documentation and inspiration of these experiments.

Please: Read, Write, Download and above all MAKE.

For this project (which I presented in December) we were fortunate enough to actually have a “client” - Living Classrooms, a Baltimore based NPO focused on educating “at risk” people of all ages. The program was a design exploration for a new center they are planning to build in DC on a site immediately adjacent to Navy Yard.

I began the project by writing a simple rhinoscript (top portion) which created a pallet of program “blocks” for to use in exploring massing and program configurations. The script takes 2 inputs - minimum width (of the program element), and height as determined by some initial research into optimal dimensions for classrooms, multipurpose spaces, etc. Additionally I organized the program on a gradient from program that should be prominently visible to the public in the massing to those that should be private. Using this analysis I began to explore how these concepts might manifest in the formal expression of the building, particularly as it related to the public site along the Anacostia River.

Images are large, so please be patient.