Let’s Face It. Connecting Nodes Sucks

I remember back in College I foolishly decided to dive into a generative design studio. I set out to use grasshopper for the first time. It was magical. I created a point with three inputs, a second point with three more inputs, and then I connected the two points with a line node. The total effort? 9 nodes, 1 line, 30 minutes, three online tutorials, and one tall coffee.

Visual scripting example

Given this introduction to visual scripting, I had in the back of my mind that mass-adoption would take decades for this kind of thing because the barrier to entry was so high. Let’s face it: drawing a line on paper is easy. Drawing a line in CAD requires you to type “line”. Drawing a line in grasshopper requires a 30 minute tutorial. It is not the most intuitive of things.

Introduction to Algorithms

Hello. My name is Clifton Harness. I am a CEO. This doesn’t mean much, other than people are more likely to return my sales emails because they know who they are dealing with (maybe?). I have a B.Arch from The University of Texas (Hook ‘Em) and I worked in Real Estate Development for two years. I made the conscious decision to quit my job (a very fiscally irresponsible one) to do a software startup. TestFit was founded to help architects and developers get to the highest-and-best use for real estate (nearly) instantaneously. In this artfully written post I will describe four algorithms that we built, and how they stack up against Design Script (Dynamo).

What is an algorithm? Easy. It’s a list of steps to follow. You do them all the time, every day. Lets look at one together: Not waking up.

  1. Realize sleepy time is now over
  2. Open Eyes
  3. Heavy sigh
  4. Roll over
  5. Close Eyes
  6. Fall back asleep */ Stay in this loop */

What just happened? This is the algorithm for sloth.dyn. I do this almost every day, and despite my wife’s many interrupt handling functions, nothing has changed. All an algorithm is? A list of steps to follow.

An Algorithm for the Placing of Fire Walls

TestFit: Placing Fire Walls

This one was extremely difficult for me to put into words how it should work, but my partner (genius software developer) came up with an amazing solution. We (he) wrote some code to do this instantaneously. Some basic rules:

  1. Buildings should have an adjustable maximum size
  2. Minimize the number of buildings
  3. Don’t place firewalls in corners

With this code, I will never draw another polyline. Ever.

An Algorithm for Placing Staircases

TestFit: Placing Staircases

This one is easy.  All we need are some rules to follow. Stairs should be placed within 50 feet of a dead end corridor

  1. Stairs should be placed at least every 250 feet from one another
  2. Place at least one stair per building area
  3. Place a stair in the corners of the garage

We slowed down the algorithm by an order of several magnitudes so that you can see what is happening. With this kind of logic we can place not only stairs but could be expanded to place other kinds of rooms, such as mechanical rooms, IDF closets, or elevators.

An Algorithm for the Placing of Units

TestFit: Placing Units

This one was much harder, and I won’t go into a great deal of detail, but the basic premise is to try to course units perfectly given the shape of the building and the size of building mass you are attempting to fill with units. Units have criteria on widths, depths, size, and glazing requirements.

An Algorithm of Many Algorithms

TestFit: Multiple Algorithms

When we take these three algorithms and have them work together, we have a pretty useful test-fit solution for multifamily buildings. I skipped a lot of detail, because that is our intellectual property (I hope you understand), but gave enough for you to get a sense of what is actually going on under the hood of this software.

The Explosive Power of Dynamo

TestFit: Dynamo

TestFit is a test fit solution (did we name it correctly?). A test fit is a diagrammatic wireframe–it is not a building. How can we make it into a building? In this sample dynamo script, we turn that wireframe into Revit geometry. I cannot even imagine what a proficient dynamo programmer could do with this. I am thinking they perform VDC operations onto the wireframe, start building out rooms with doors, windows and facade details. Even better? Do energy analytics, start running mechanical systems, or costing information. But that is a painfully limited scope of what dynamo can do. Its true power is that it is broad in scope–a lot of different things can be done. TestFit is narrow and powerful. Both of these together? Lethal.

The Future of Generative Design

TestFit: Generative Design

Point solutions for specific typologies and morphologies written in custom code (like python or C) will knock Generative Design out of the park. We did 120 iterations (imagine a million iterations!) on a site and came back with a fat stack of data to analyze. Trace paper cannot compare to this. The problem is that most generative platforms (I am looking at you project fractal) don’t constrain the geometry enough for the result to be worth anything. With TestFit, we will get to the point where the geometry is constrained enough for generative design to make sense. Some examples of constraint:

  • Adding additional fire stairs, when buildings get too big
  • Adding additional elevators, when buildings get too tall
  • Growing parking, when units become too numerous
  • Regulatory constraints (max FAR, max lot coverage, max height)

With these constraints plugged in, we can then pursue goals to achieve for the generative analysis:

  • Most energy efficient
  • Most natural light
  • Most economic to build
  • Best views from the building

Without a proper constraint engine that encompasses almost everything, the goals to achieve are useless. We are building that constraint engine, right now, and for us it starts with TestFit.

Clifton is CEO of TestFit.io.  You can learn more about Clifton at https://www.linkedin.com/in/cliftonharness/