This is the third and final phase of the course. A site and program will now be introduced. They are not meant to be the subject of inquiry, but devices to further your research. The site and program will provide resistance and motivation, but successfully responding to their forces is only the beginning. They are given, fixed, and fictional (although based on facts). The “big questions” that initiated our work must continue to be addressed: how does drawing mediate/influence/fuel/ disrupt the relationship between you, computing and architecture? When and how can the process of drawing a project become the project? Extend your work from phases one and two and continue to design a design process. Continue to experiment with the relationship between drawing and space. How, with what media, and with what machines you do computation is open. We will consider and discuss the role of automation, indirection, instruments and knowledge under the conceptual umbrella of authorship.

The site and program are a replacement for the existing Post Office and Postal Service warehouse at 25 Dorchester Ave, Boston, MA 02205. The program follows.

• 195,000 SF of open warehouse space (40’ high ceilings required; direct natural light is not desired; fresh air and ventilation may be considered);
• 1,000 SF of publicly accessible “retail” Post office program (which includes access to Post Office boxes, a self- service counter, a physical interface with Postal Service Personnel, and space for customers to line up and wait);
• 500 SF of publicly inaccessible space for Postal Customer Service personnel on the other side side of the customer service interface and adjacent to the public program;
• a 350 SF break room for Postal Service Personnel; and four publicly inaccessible all-gender restrooms for Postal Service Personnel.

The vehicular circulation system around the site is to remain similar to its current configuration. 18 truck loading docks on the publicly inaccessible portion of Dorchester Ave are required. Separate entries for Postal Service personnel and the public are required. As is the case with the existing building, one floor of the warehouse space must be contiguous with the Postal Service Inspection Building to the SouthSouthWest. The boundary of the site may be expanded to include a portion of what is currently the South Station platform and the landscape at the corner of Summer St. and Dorchester St. However, the footprint of the building may not extend beyond its current shape.

The program and site afford many opportunities to advance and question the conception of a corner, the perception of thickness, and multiple conceptions of inside and ourside. Consider, for example, that the public portion of the program could be thought of as an object within the reletively vast landscape of the warehouse. Consider, alternatively, that the public program could be interperted as an excavation out of the perceived solid of the warehouse volume.

In this phase of the course, drawings, by necessity, serve a function: abstraction for the purpose of communication and operation. Many drawings result from projecting three-dimensional geometry onto a two-dimensional picture plane and deploying graphic conventions. However, these drawings are also treated as autonomous works of architecture. Besides conveying something, drawings can be something that can be read, interpreted, and expanded based on its own implied structure. During this phase of the course, students are responsible for creating multiple cycles of movement between drawing and building.

The first order of business is to design and fix a certain set of conditions unqie to each students’ project. Making some early decisions and removing them from the possibility of reconsideration ensures that for the weeks ahead, drawing and computing can be explored with respect to a building rather than working slowly towards a building. We will discuss more about these given conditions, which may include materials, program arrangement, structural systems, spatial grids, and building envelope dimensions.

Readings: Over the course of the remainder of this phase, students will be assigned one reading to master taken from the list of previously provided essays and some new additions:

• Malcolm McCulough: 20 Years of Scripted Space
• Antoine Picon: Forward to Algorithmic Architecture
• Lewis, Tsurumaki, Lewis: Intro to Opportunistic Architecture
• Donald Kunze: Concealment, delay and topology in the creation of wondrous drawing Tim Ingold: Traces, Edges and Surfaces
• Kenneth Frampton: RAPPEL A L’ORDRE THE CASE FOR THE TECTONIC
• Ivan Sutherland: excerpts from Technology and Courage
• Leo Steinberg: The Authentic Set

Here are two versions of the script, a simple and a more advanced, which we discussed in class. See the comments in each for more info.

• rhinoToHPGL-simple.py (ZIP)
• rhinoToHPGL-advanced.py (ZIP)

In class today we modified some of the example scripts I made and explored a few new strategies

• modified: drawGridOnSurface_triangles.py (ZIP)
• modified: porcupine_inwind.py (ZIP)
• a quick example of for loop with range() and enumerate():rangeexample.py (ZIP)
• a new one, mapping from the world x,y to a surface u,v: map.py (ZIP)

• porcupine.py (ZIP)
• drawGridOnSurface.py(ZIP)
• straightLinesDependingOnDistance.py (ZIP)

Super important: the documentation

the code from class today: quickrhino.py (ZIP)

• Excerpts from William Empson’s Types of Ambiguity (PDF)
• P-TR’s Progress by Jeffrey Kipnis (PDF)
• Antoine Picon’s Forward to Algorithmic Architecture (PDF)
• Transparency: Literal and Phenomenal by Rowe/Slutzky (PDF)

Part A . Amass a collection of ten corners; five found and five made. The found corners should all be parts of built architecture, each documented in a single photograph. Print these photographs on 7” x 8” portrait-oriented paper. Identifying corners is easy, so it will be important to maintain high standards during your search. Be prepared to argue for and/or prove that the architect of these corners addressed the corner as a particular “problem” or opportunity. The made corners will be submitted as digital files. Each should be comprised of no more than four surfaces. (In anticipation of questions: No poly-surfaces, no curves and no lines; “Surface” does not mandate nor preclude planarity; Scale and material are not in play. This is an exercise in geometry.)

Part B. After consultation with the studio, identify one made corner. Render this corner with lines–and no other form of mark or tone–on paper. Be sure your system of rendering, which you will design and code, articulates form and allows the reading of form in 3-D space. Then, revisit the model and make changes based on analysis of the drawing. Allow your foreknowledge of the next iteration of rendering to influence the model. Introduce more surfaces if necessary. Render the corner again with lines–and no other form of mark or tone–on paper. Repeat this cycle as many times as you determine to be necessary.

Part C. Revisit your model and make adjustments in anticipation of another rendering, but this time the rendering will be generated by light simulation software rather than articulated in a line drawing. Density of line will now be articulated by the edge of surfaces, so the quantity of those surfaces in the model will likely need to increase substantially. Likely your method of modeling will shift also to include coding to form surfaces. Reference, draw from, and learn from the found corners. Generate a rendering, make adjustments to the model then generate a second rendering.

Part D. Expand your model to include an ambiguous conception of solid/void. Introduce at least one additional corner to assist in achieving this ambiguity, which is to correspond to literary theorist William Empson’s “seventh type.” Consider how depth, line, pattern, shape and surface work together and in relation to one another to create this ambiguity. Render this construct with line and, if necessary, tone using any combination of techniques onto 21”x24” paper (portrait orientation). Produce a diagram that explains the two conflicting readings of solid/void.

Assignment sheet (PDf)

today in class today I showed:

• How to adapt the blendcurve script to receive user input (and only plot once while remaining on the screen: blendLines_userInput.py
• How to mark segments on a sine curve: drawPointsonSin.py (ZIP)

Reading these will be helpful at this stage

• Tim Ingold. Excerpts from Lines, A Brief History (PDF)
• Deanna Petherbridge. The Primacy of Drawing, Histories of Theories of Practice. Chapter 4, “Line Mark, Linear Codes, and Touch.” (PDF)

These two completely unrelated examples might be relevant to many students

• creating a function:function_example.py(zip)
• blending between two lines:blendLines.py(zip)

First of all, make a note of the manual. And Here are two examples of ways to use the library:

• Controlling the pen plotter directly: plotting-basics.py (ZIP)
• Generating a file to plot later:plotting-generating-HPGL-file.py (ZIP)

to access and the file that chiplotle library uses to communicate with plotters:

• first, to show hidden files in Mac OS, open the terminal and paste the following line of code
• defaults write com.apple.Finder AppleShowAllFiles TRUE
• then press enter
• The config.py file can be found within the .chiplotle folder, inside your home folder

These are the settings for the Roland Plotters:
baudrate = 9600
bytesize = 7
parity = ‘E’
stopbits = 1
timeout = 1
xonxoff = 1
rtscts = 0

These are the settings for the HP plotter:
baudrate = 9600
bytesize = 8
parity = ‘N’
stopbits = 1
timeout = 1
xonxoff = 1
rtscts = 0

these scripts have detailed notes inside them, which should make it easy to follow

curve through points (slightly different from Bezier curve): interpolated_curve.py

using the transform functions and transparency: transparency-and-transformation.py

even if these examples aren’t directly relevant to you, have a look at the portion of the script that saves an image, which will be useful for everyone

First, there are two libraries that Chiplotle (the library that allows us control the plotter) requires, (dependancies) which will need to be installed before anything else: Pyserial and Numpy. You will also need the driver for the physical USB-serial adapter.

installing these first three are straightforward installer apps:

• MAC USB-Serial Driver
• MAC Numpy
• MAC Pyserial

The Chiplotle library is slightly more involved, and we’ll do this as a group in class:

• Chiplotle-0.4.1

This is the Chiplotle documentation site: http://music.columbia.edu/cmc/chiplotle/manual/

• Python 2.6.6 installer (.dmg)
• Pygame (.dmg)
• download sublimetext2
  • copy app to applications folder, launch app
  • from within sublime text 2, from the menu choose sublime text2 ->preferences->Browse Packages
  • open Python folder
  • find Python.sublime-build and right click ->open with sublime text 2
  • leave sublime text as it is–you’ll come back to it in a moment–open terminal (applications/utilities)
  • type the following line and press enter:
    which python
  • the result should look something like (if not exactly like):
    /Library/Frameworks/Python.framework/Versions/2.6/bin/python
  • copy that path (the entire line in terminal) and go back to Sublime Text 2 and paste it into the file you have open in SublimeText2 inside the first set of quotes to replace Python in the first line so that it looks like:
    {
    “cmd”: [“/Library/Frameworks/Python.framework/Versions/2.6/bin/python”, “-u”, “$file”],
    “file_regex”: “^[ ]*File \”(…*?)\”, line ([0-9]*)”,
    “selector”: “source.python”
    }
    
  • file->save
  • quit and reopen SublimeText 2

Part A: Amass a collection of nine examples of drawn lines made by artists, designers and architects. Print them on 7” x 8” sheets of paper and label them with bibliographic source information. Then, choose three kinds lines from your collection. For each, articulate three different methods one could use to recreate those lines for a total of nine articulated methods. Focus on the geometric and aesthetic characteristics of the line. At this stage, don’t be concerned with media, material or tools. Write in English and avoid ambiguity or a reliance on interpretation of your words.

Part B: Choose one kind of line from your selection of three. Alternatively, combine two or more kinds of lines together to form a new hybrid type. Write Python Code to recreate, and then extend, that line. Exact replication of the original line is not important. Allow your interests and the medium to influence the outcome. Begin by drawing in pixels on screen before you transition to controlling a machine that marks paper. Draw your line for multiple durations at multiple scales. Use a fresh piece of paper for each iteration of your line.

Part C: Make an 21”x24” architectural drawing with the 24” side oriented vertically. This drawing should contain multiple–perhaps thousands, perhaps three–iterations of your line. This drawing may elicit representational qualities but will not be overtly keyed to any representational system. It will not be to scale and will not correspond to any subject. Challenge your lines to convey depth and define space. Consider a controlled ambiguity between the 2-D space within the paper and a represented 3-D space perceived in the drawing. Respect the boundary of the page. Move beyond the definition of a drawing as a collection of lines into that of an expressed relationship between lines. How can lines perform collectively? How do they influence each other? As you work, also consider what inherently “architectural” problems your drawing can enlighten. Corners and edges are favorite foundational elements of architecture in this studio, but perhaps other productive “problems” can be articulated and explored.

Full Phase 1 Assignment Sheet (PDF)

This studio explores computer programming as a design medium. Programming, defined as the design and execution of algorithms, allows designers to tap into the science of computing in ways that more fashionable approaches to digital media (parametric modeling, for example) preclude. How programming can and should be used to conceive of architecture is a perpetually open question. Rather than immediately computing architecture, this studio begins by computing drawing, which by definition allows the human eye and mind to play a prominent role in design. Conceptions of authorship, ambiguity, and representation remain the focus of attention and criticism as the course moves from drawing to building (and back to drawing).

The studio, as a community, cultivates an actionable obsession with three foundational elements of architecture: line, surface and corner.

Beginning with a kind of calisthenics in the Python programming language, students control a machine (pen plotter, laser cutter or other) that affects paper by marking line(s). Computed (and computing) lines are sorted, grown, aggregated, tested, indexed, critiqued, extended, constrained, broken, extended, etc. In other words, we draw. The inquiry at this stage includes an analysis of linear precedents in art.

The second phase involves lines in space defined by rendered surfaces and articulated as edges rather than marks. The inquiry at this stage includes an analysis of lines and corners in architecture.

The third phase sees the introduction of an urban site and a 100,000 SF program. This large building will have a small portion (925 SF) that is different than the rest. The exact site and program details are revealed later. Computing in the realm of drawing remains a generative force in this phase. Techniques and languages used to represent the building at this phase will influence details, material, and structure. This is is the third of the “Computing Drawing” series of studios offered in the spring since 2013. Each subsequent studio is heavily influenced by the research, opinions, successes and failures of students in previous studios.

After the final review we formed a corner and represented it with competing depth cues

bye!