The effort could not be conducted within project-driven research because of limited budget and time. Thus, the idea of integrating structural design tools into a parametric design environment became a joint venture of the engineering office and the department of structural design of the University of Applied Arts in Vienna. The fruitful collaboration yielded Karamba, a Finite Element programme for the early design phase. The software is fully embedded in the parametric environment of Grasshopper, which makes it easy to combine parameterized geometric models, finite element calculations. Structural parameters become integral design drivers from early on instead of constraints in later design phases. The digital model becomes more than pure geometry representation; it is informed with structural capacities. The parametric design approach allows for geometric variation combined with the immediate structural analysis we are able to generate site-specific structure beyond preconceived typologies.
References
Bentley, P. J.; Corne, D., 2002: Creative Evolutionary Systems. San Diego: Academic Press.
Billington, D., 1985: The Tower and the Bridge. New York: Princeton University Press.
Bollinger, K.; Grohmann, M.; Tessmann, O.: Form, Force, Performance: Multi-Parametric Structural Design. In: Hensel, M; Menges, A. (eds.): AD Architectural Design, Volume 78, Issue 2. Special Issue: Versatillity and Vicissitude, 2008, pp. 20-25.
Matthek, C.; Burkhardt, S.: A New Method of Structural Shape Optimization Based on Biological Growth. International Journal of Fatigue, Volume 12, Issue 3, May 1990, pp. 185–190.
Preisinger, C.: Linking Structure and Parametric Geometry. In: Peters, B.; De Kastelier, X. (eds): Architectural Design Computation Works: The Building of Algorithmic Thought, John Wiley & Sons, London, 2012, p. 111-114.
DesignScript: A Learning Environment for Design Computation
Robert Aish
Abstract Design computation is now an established part of architectural design education and practice. The challenge is to encourage designers with the minimum of prior knowledge to become operational with computational concepts but without being subsequently limited by any simplified approaches that might have been initially offered. This paper describes recent progress in the development of additional intermediate tools which are intended to encourage the designer to progress to more complex computational ideas and their successful application to design. Here it is suggested that an appropriate design computational toolset should offer a progression of concepts, tools and forms of user interaction that match the expected progression in skills and ambitions of the designer.
Robert Aish
Autodesk, London, United Kingdom
1 Introduction
Design computation is understood to mean the direct application of computational concepts and operations to the formulation and resolution of design problems. In this approach, the designer, architect or engineer, etc. - directly or indirectly - writes a computer programme whose execution generates the design configuration and geometry. This can be contrasted to other non-computational forms of design, where the final resulting configuration and geometry are manually constructed by the designer or draftsman potentially with the assistance of an interactive computer graphics application. In this manual approach there is no representation of the design logic or intent which is independent of the geometry created.
In computational design, the designer must not only think about the result that he wishes to achieve but also the exact sequence of operations or intermediate constructive elements that when executed will achieve the desired outcome.
Design computation is an example of an investment-reward process. It is generally agreed that if the designer can make the initial investment in such a generative programme, then it will be subsequently much easier to explore alternative design options simply by changing the value of the driver variables, watching and evaluating alternative designs being generated. The challenge is to create a computation environment which can provide a gentle learning curve for designers with little or no prior computational experience to start this investment-reward process. Such a system must both provide the designer with immediate practical results, the reward, and at the same time encourage him to take risks and explore new unfamiliar concepts and techniques, the investment.
1.3 What Are the Characteristics of Computational Tools That Are Appropriate for Design?
To create a successful design-computation system, which can be an appropriate learning environment, we have to address the process by which designers express design logic both either explicitly or implicitly as executable code and the characteristic of the tools or languages, which might be used. For example, how do the characteristic of the tools and languages relate to the skills or interests of the designer?
In the main, conventional computer programming or scripting languages, such as Python, Java, C# and VB are based on imperative programming. “Imperative programming is a programming paradigm that describes computation in terms of statements that change a program state. In much the same way that imperative mood in natural languages expresses commands to take action, imperative programs define sequences of commands for the computer to perform”[1].
There are many successful examples of imperative languages being used in design computation, but for the designer with no prior computational experience these languages often present an abstraction barrier. “The abstraction barrier is determined by the minimum number of new abstractions that must be mastered before using the system” [2]. Applying this to learning and using an imperative language, and we can see that the number of abstraction that have to understood and operationalized is quite daunting for designer, as the novice programmer.
The question remains, how can we offer tools to the designer that avoids this initial abstraction barrier? The long-term objective is not to encourage the designer to completely avoid imperative programming. Indeed this type of programing has considerable applicability and value to design computation and the abstraction barrier is not insurmountable. The approach proposed here is to gradually introduce this and other advance computing concepts via a less arduous route and at the appropriate moment when the designer has recognised the limitations of other more easily learnt approaches.
2 Data-Flow Programming Using Graph-Node Diagramming
In response to the limited success of text based imperative language in design, a completely different approach to computation, called dataflow programming, has emerge. “Dataflow programming is a programming paradigm that models a program as a directed graph of the data flowing between operations, thus implementing dataflow principles and architecture”[3].
Typically, graph nodes represent operations, including the data resulting from these operations, and the arcs of the graph represent the flow of data, including the implied dependencies, between nodes. Applications such as MAX-MSP [4], GenerativeComponents [5] and Rhino Grasshopper [6] are examples of a dataflow approach to design computation.
A particular advantage of dataflow programming is that the underlying graph can be represented visually and this provides an intuitive users interface for end-users with little or no programming experience. Indeed, the success of these applications is mainly due to the way in which designers, as novice end-user programmers, have been able to express design logic without having to acquire knowledge of conventional programing syntax. Quite possibly, the designers using these dataflow applications do not even consider this to be programming.
There are two criticisms of graph based data flow applications. The first criticism is that the human use of such dataflow systems does not scale to complex problems. Of course the graph technology can deal with thousands of nodes. But a design computation application is an example of a man-machine system and the art of designing a successful man-machine system is to match the characteristics and representation of the machine component to the capabilities of the man. It is the human capacity to comprehend