quasiGRAMMARS Submition

Serdar Aydin
A Parametric Quasi-Grammar for Generating a Flexible Urban Design

Tool: Shape Grammars Optimised by Evolutionary Algorithms

submitted by Serdar Aydin BArch
for the degree of MA of the University of Liverpool
2012

MA Architecture in the Liverpool School of Architecture
University of Liverpool
A Parametric Quasi-Grammar for Generating a Flexible Urban Design Tool i

A Parametric quasi-grammar for generating a flexible
urban design tool: Shape grammars and genetic
algorithms*

Abstract
Computational design has recently come to recast the conventional urban design
strategies. The complexity of urban planning exceeds the potential owned by
manual design techniques to produce an array of distinguishable solutions while
competent to deal with varying demands during urban design process. This paper
explores the means to create a flexible urban design tool that could afford to
conceive complex solutions with cooperative computational design techniques. The
computational process defined to accomplish a flexible tool is divided into two
parts; shape grammars and evolutionary algorithms. The flexibility to satisfy
constantly changing demands is constituted by parametric shape grammars that
consist of variables. Genetic algorithms and genetic programming are compared
and suggested to meet the optimisation problem of the flexibility controlled by
parametric variables which are described by shape grammars. Since these
techniques imitate evolutionary theories, primitive urban patterns and the
philosophies in the background are discussed to elucidate the concept of urban. In
so doing, it is aimed to adhere to a theoretically rich foundation on which a robust
design tool could be built.
Aydin, Serdar
200843846,
ARCH 481, Dissertation,
University of Liverpool,
UK

*For the web-presentation of this research, please follow the link under the references of websites
at the end of this paper.

A Parametric Quasi-Grammar for Generating a Flexible Urban Design Tool ii

With regards to a pragmatic explanation, urban neoliberalism is addressed as it
paves the way for large-scale developments. Urban projects such as urban renewals
and neighbourhood extensions are prevalent implementations of Neoliberal
urbanism in fast-growing countries where the accelerated urban design practices
cause the distortion of existing urban texture. The parametric urban design tool
proposed in this paper pays special attention to the coexistence of the new and old
in harmony with each other. Therefore, the goal of this paper is to present a
guidance for a computational solution within this complexity.

A Parametric Quasi-Grammar for Generating a Flexible Urban Design Tool iii

Acknowledgements and Thanks to

Turgut Cansever, thinker and architect, for being a great resource in the theory of
architecture and urban design since my second year at university.
Nicholas Webb, PhD researcher, for being my thesis reader, and for all his
suggestions and advice.
Mike Knight, for taking the time to talk with me about computational design tools,
and for his advice about parametric design.
Jose Duarte, for providing subsequent knowledge about using shape grammars in
urban design.
Ben Fry and Casey Reas, for their open project Processing helping me have
programming experience.
The Ministry of National Education of Turkey, for awarding me a YLSY
scholarship, and for enabling me to come to Liverpool.
Xue Ai, my group-mate in most of the works during the MA programme, for being
supportive and critic of my works all the time.
My friends in Liverpool, for literally bearing with me to live together abroad, and
for joining me to drink Moroccon mint tea at Kasbah on Bold Street, and all the
people who feels with me all the time.

Finally, the biggest thank-you to my family for being always there for me. My dad
(who first taught how to design his furniture workshop), my mum, (whose needle
lace works gave me elegancy in design), Elanur (who has always been a lovely
sister to me), and my brother Ilker (who always trusts and supports me). Of course,
special thanks to my aunt (who is busy with raising her children nowadays).

A Parametric Quasi-Grammar for Generating a Flexible Urban Design Tool iv

Contents

Abstract i
Acknowledgements and Thanks iii
Contents iv
List of Figures v
List of Tables v
Introduction | Paradigm Shift 1
Chapter 1 | The problem in the broad context 4
Growing and Complexity 5
Urbanisation and the Image of City Throughout the History 5
Computation for a Logical Randomness 8
Chapter 2 | The solution in the broad context 14
Complexity and Randomness 15
Bottom-up Approach and Complex Girih Tiling 16
Criteria for Success 21
Chapter 3 | The specific problem 25
Large-Scale Urban Projects and High-Rise Shortcuts 26
Mozart and Complexity 27
China and Turkey: Still far from Mozart 28
Chapter 4 | The specific solution 31
Computation for Liveable Urban 32
Set Grammars and Parametric Shape Grammars 36
Shape Grammars to be Optimised by Genetic Algorithm Techniques 38
Genetic Programming in Processing 40
Conclusion | A Paradigm Shift: Looping From Theory to Tool 45
References 49
Appendix A | AutoLISP - Processing 53

A Parametric Quasi-Grammar for Generating a Flexible Urban Design Tool v

List of Images and Tables

Figure 1: Kaisersrot, Oqyana
Figure 2: Raphael, the School of Athens
Figure 3: Paris Arc de Triomphe, http://www.vancouverlifestyles.com/opinion/urban-
laboratory/top-5-urban-innovations-2-5-haussmannization-paris
Figure 4: Mongolian tents, "Yurts", http://simplyyurts.co.uk/yurts.php
Figure 5: Le Magasin Pittoresque, taken from Intimate Metropolis
Figure 6: Serdar Aydin, crossover in GA
Figure 7: Serdar Aydin, crossover in GP
Figure 8: Riether and Baerlecken, Girih tiling
Figure 9: Agnes Csanady and Hans-Ude Nissen, quasi-crystal ref. by Istvan Hargittai
Figure 10: Jose Duarte, Joao Rocha and Ducla Soares, Marrakesh
Figure 11: Andrew Crompton and Frank Brown, Venice
Figure 12: from Wolfgang von Kempelen - The Turkish Chess Player. Copper engraving
from the book: Karl Gottlieb von Windisch, cited from Sha Xin Wei
Figure 13: For Public Use, http://en.wikipedia.org/wiki/File:Turk-knights-tour.svg
Figure 14: High-rise housing development in Hong Kong, Gutierrez + Portefaix, 2003
Figure 15: Ercan Yolgiden, TOKI building
Figure 16: Serdar Aydin, flow of generating a flexible tool
Figure 17: Serdar Aydin, major shape grammar interpreters
Figure 18: Serdar Aydin, optimisation of shape grammar rules by genetic algorithms
Figure 21: Serdar Aydin, differences between GP and GA
Figure 22: Serdar Aydin, processing programming language, in Processing 1.5.1
Figure 23: Serdar Aydin, drawing a point in Processing, in Processing 1.5.1
Figure 24: Carl Carlsen, Living Net, http://sixthsensor.dk/code/p5/point2line/index.htm
Figure 25: Andreas Schelegel, controllers, http://www.sojamo.de/libraries/controlP5/

Table 1: Serdar Aydin, basic elements and operations in coding
Table 2: Stages of parametric shape grammars with optimisation algorithms
Table 3: A list of shape grammar interpreters
A parametric quasi-grammar for generating a flexible urban design tool 1

Introduction
A PARADIGM SHIFT


Paradigm Shift
To mention a paradigm shift on planning process specified in the context of
urban development, the history of conventional approaches, the philosophies
backing these, new computational approaches and their history will be put in
order below. Then the focus will be so-called revitalisation projects around the
world. A brief description of the method, that is followed to generate a genotype
and thus a series of phenotypes, will be taken in before explaining how to
generate programming by using shape grammars.
The aim of this paper is to shed some light over the problem of urban design that
lacks flexibility and comprehensiveness on the end-product. Optimisation search
techniques and programming the grammar of existing urban texture will be
explored by a computational design tool. The body of the paper consists of four
major parts; an urban problem in the broad context, a computational solution in
general, the specified problem in the name of Neoliberal urbanism and the solution
proposed with regards to a flexible urban design tool.
In the first chapter named Fast growing and complexity, the theoretical
background of urban creation will be discussed in the format of a typical historical
research. It starts with the description of urban space made in ancient Greek times.
From Mongolian perception to the Napoleonic urban design strategies, the
relationship between design process and its philosophical background will be
covered. This chapter will include the urban design problem which is taken into
consideration in a broad context to understand what is basically needed, which will
be inferred to be randomness.
Having been concluded that computation is reasonably able to overcome the
outcome of urban disease formerly described, its history will be put ahead by
highlighting important points.
The second chapter, Complexity and randomness, will be speaking of the solution
in general terms referring to computational techniques. Computational definitions
will be made for the proposed programming language with which a programmer
would feel relatively more familiar. In essence, the power of computation to solve
the complexity in randomness will be questioned after which an algorithmic

process will be briefed in the following chapter. This chapter will also be
presenting computational algorithms that are able to generate an efficient
modularity without the stagnation of information carried. These two chapters could
be united into one but the latter distinguishes its own by including more detailed
historical and theoretical information about the use of computational design
techniques.
The urban design problem put ahead in chapter 1 will be specified in chapter four,
whilst, in chapter 3, large-scale urban projects and high-rise residential
developments will be raised into a question of financial concerns and fast growing.
Therefore, China and Turkey following a Neoliberal development strategy for
urban enhancement and regeneration projects will be analysed to show some hints
about the current problem destined for a sort of profound explanation. This chapter
could be found under the title of Large-scale urban project.
Having specified the problem and the way of solution that this paper will follow,
computational design techniques will be cast with an example by Duarte et al
(2007). Chapter 4 is named as Computation for liveable urban. Shape grammars
and genetic algorithms will be described in detail in this chapter. Different means
to combine these two will be tested and recommended as a conclusion. More
interestingly, genetic programming will be explained with flow charts for a further
development, which is also previously compared to genetic algorithms in chapter 2.
At the end of this paper, an appendix is added to show two basic samples. One of
them is generated to design complexity in AutoLISP and the other one is applied to
a genetic programming in Processing.


Chapter 1

The Problem in the Broad Context
FAST GROWING AND COMPLEXITY


Growing and complexity
Designing complexity mostly becomes unaffordable due to the concern with
financial risks. Not only the inclusiveness of social participants, but also technical
details such as infrastructure help increase the complexity. On their explanation for
the Oqyana project in Dubai (see Figure 1), Braach and Lehnerer summarise that
all the differing demands must be integrated into a consistent and stable master
plan (Hovestadt 2010). In order to achieve manageable urban planning, it has to be
flexible in comparison to the conventional approaches. This briefly means to
design a complex system which is driven from simple rules to make the process
affordable and easy to control. If succeeded, it would be a paradigm shift in the
design environment.

Urbanisation and the image of city throughout the history
An urban pattern is the uppermost image of a civilisation whose fundamental
intention is to complement the meaning of its existence in its cities accommodating
distinct professions that interact in harmony with each other (Cansever 2011).
Therefore, it is the search for a comprehensive ideology ahead of which an urban
system is tagged on at background.
The shape and form of cities has always been the subject of philosophical discourse,
resulting in theoretical interventions, utopian visions, symbolic constructs or
speculation about the future. Two and a half millennia have now passed since Plato,
Aristotle and their friends raised questions about the ideal size and form of cities as
well as their social organisation (Cuthbert 2006, 52-53). They imagined the city as
demarcated from others, serving to certain strata, actually not serving but being
consumed by them, and the others such as villagers and slaves serving them. The
present interpretation of this stratification could be still observed in the
contemporary urban forms whose direction of growth is monolithic in order to
escape from complexity that is comparatively expensive to sustain.
Urban Pattern
What an urban design needs is basically a manageable system. The self-perception
of a society plays a major role to create a consistent system for an urban pattern.
Figure 2: Raphaels fresco, the
School of Athens
Figure 1: Asection from the
Oqyana project (2006) by
Kaisersrot. This software is
specifically programmed by
the design team for each
client, allowing clients to
take place in decision-making
process in the determined
parameters of technical and
architectural constraints.

Throughout the history, the world has seen distinguishable urban characters such as
Roman cities, Napoleon's Paris, Chinese Beijing, Ottoman neighbourhoods and
social housing in England. They all symbolise an idea perceptible from inside,
understandable from out. If the pattern is not perceptible and understandable then
to talk about the presence of a system is very hard. Other examples lacking a
system should not be ignored though.
Planning and Philosophy
Looking deep inside urban design it can be concluded that the philosophy helps an
urban character form along a process. The capability of this process to grow or
diminish exponentially entails a controlled mechanism and a systemised planning
which is to allow a foreseeable future for the society. At this stage, planning and
philosophy unavoidably encounter because of being relatively about future. It then
should be named future planning which designates next generations rather than
present possessors. This requires a flexible design strategy which would allow the
next generation to exploit the opportunities they are likely to face.
However, this has been very difficult for the societies whose philosophy is
considered to be perfect, which in turn results in static urban forms and structures.
This creates a contradiction between the natural cooperation of all beings and what
is produced. Such urban forms can be called perdurable because they represent
their authorities' desire of immortality. Napoleon's Paris is such a design process
that everything happened from the scratch only to show the greatness of the power
and nothing else.
Static forms and top-down approaches
In contrast to the flexible use of the seats in the Luxembourg gardens in Paris,
allowing people to change their place to position themselves well, yet, Napoleon's
Paris was to show a top-down approach. The only thing that the Parisians could be
proud of was the power of the designer's predecessors in decision-making. Central
Paris now seems an entire image of a static philosophy whose edges was described
by Descartesian approach that supports the urban to take a hierarchical form and to
create the society according to this (Cansever 2012).
Ironically, the philosophy represented by this violent approach is designated as the
basement of the humanism, thus individualism, which, I think, does not accept the
Figure 3: Paris by Napoleon in
collaboration with Haussmann

ignorance of people, real owners and locals, namely participation. Instead, this led
the popular saying of its time that the environment is for us and we must use it as
our servant (Marxs humans as free, purpose producers). This process never
contributed to a three dimensional quality, concerned with the detailed beauty of
stone-like facades which is of no function at all.
In contrast the most dynamic approach is that of nomadic cultures such as the
Mongols led by Genghis Khan. They gave unforgettable lessons to wherever they
occupied by wiping out any banal forms exquisitely built. Before straying from the
topic too much, a brief explanation for the traditional approaches is put below.
From top-down to bottom-up
Medieval approaches used to be managed by an individual designer whose action
depends on his predecessors. It then became more professional that the designers'
independent and intuitive design ability has carried solutions for urban planning.
However, it brought about a new issue that the designer has been characterised as
an artist working with catchwords, personal idioms and intuition (Alexander 1964).
Top-down approaches emphasized the full control of the designer whose aim was a
contentious topic because the solutions were benefitted by the gentry. In the first
sentence of the introduction for Intimate Metropolis, it is said that at first glance,
our title may seem a provocation: surely the modern city has little to do with
intimacy. Yet, it continues, if we consider the assertion that in the modern polis it is
in private, rather than in public that freedom and fulfilment are to be experienced
(Palma, Periton and Lathouri 2009, 1). The methods moulding the modern cities
have seemingly failed by relinquishing its moral responsibility for a detailed
planning in the name of progress and better life. Therefore, this has been seen as
the annihilation of freedom which could only be accomplished by people
themselves, namely participation or, in the methods' language, bottom-up.
Having been summarised above, conventional urban designs tend to be like binary
solutions promising 'perfect-like' results without considering the need for a rich
diversity of possible solutions as though it will never need the better. It ends up
with a massive amount of financial and social losses no matter how sustainable or
adaptable the individual buildings are. This has been experienced and concluded
Figure 4: Nomadic Mongol
people living in tents
Figure 5: Parisian social
levels in the 19th century

that urban systems are like organisms in which any changes would require the
entire system to be reconstructed.
The novel approaches in urban design are to function according to the rules of
mutual dynamic exchange like information technology because modern urban
systems carry a range of information between differing demands which need to be
integrated into a consistent, flexible and stable planning.
The newest attempt is to push the limits of computation to fulfil the gap which was
created by modern architecture's simplistic, static and invariable approach. Though
a need of a paradigm shift has been spoken out for more than forty years, in my
personal view, we are just now on the threshold of a great shift in architecture and
urbanism as the role of computation is exponentially increasing on the design
process.
This new approach was tested by several people who attempted not only to be in
accordance with the environment but also to synchronise their design with it,
including the consideration of time as well. Then the solutions simulated on
screens become flexible giving opportunities for individually definable identities
which tend to cause complexity rather than invariance.

Computation for a logical randomness
Urban design process has never been that complex in history, with so many
different visions demanding varying types of solutions. Changing regulations,
bureaucratic procedures and unsustainable construction systems all hinder a
sustainable urban environment due mainly to inflexible design applications. This
makes the urban planning process slow down due to the consideration of financial
risks of possible failures. Growing complexity in modern cities has reached its
threshold to go beyond for a necessary change in urban planning in which even the
farthest parts need to be arranged in harmony to carry more information like a
dynamic living organism.
The traditional approach to design is generally based on the classical principle of
designing the whole as a definitive solution centred on the definition of urban

parameters, which is very attached to bureaucratic procedures, constraining design
as if it would be a mere representation of such parameters (Beirao and Duarte
2005). For some it is a sort of growth problem which nature gives best solutions
and for others the problem can be solved by means of computational calculations
and statistical analysis because of the complexity it includes.
New description for computation; far from equilibrium
In thermodynamics, the complexity stemming from certain randomness turns out
under the name of far from equilibrium whereby outcomes have productive and
unpredictable behaviours. For a mechanical system equilibrium may seem
attractive to lay out many tasks easily. But the nature as a resource of all systems
does teach us how to be far from equilibrium which describes a system being more
ordered and differentiated as it is moved from its rest places. Due to its unstable
character, a problem emerges here that solutions are initially not cost-effective,
with a lot of energy demanded to sustain the system. On the other hand, instability
is the precondition of creativity. Because of its cost, instability and invention are
rare (Kwinter 2007, 16). To this end, a paradigm shift needed is to be described for
a new computation method, thereby generating complexity far from a static
equilibrium.
Designing complexity is hard to afford, which needs so many lives to be outlined.
Then the question is what could be done to ease the architect's or planner's role.
The first thing which comes to minds is the use of computer which lies on the
thread of a hard question: Can a machine translate a sufficiently rich and complex
but at the same time affordable solution driven from simple rules? This part of the
paper will look for an answer to that question.
Something never approved is about to come into play, 'robotic cities'. It does not
sound anymore as bad as it did to the decision makers in the past. There are also
those who smooth the title by putting forward intriguing terms such as 'emergent
technologies' and 'genetic algorithm'. This smoothness is used by ill-intentioned
ones to legitimate what they do. But, there are still pretty convincing explanations
for a new kind of urban design strategy though.
If nature and computation are seen as resources for our knowledge then the
combination of these two emerge in the scope of algorithmic architecture which is

controlled parametrically and displays a growing and even responsive character
like nature. Changes or modifications to living forms occur both by mutation or
'copy errors' and by the recombination of existing information into new sequences
and patterns (Hensel, Menges and Weinstock 2010, 32).
For an evolutionary being, the more information transmitted amongst the cells the
stronger the body is. Computational algorithms investigated for this paper are
convincingly promising to deal with such accelerating transitions.
According to Weinzierl (2001), cities growing from village to megalopolis, become
huge urban areas which need to be restructured to give a more "natural" feeling of
environment to the people that live in them. A symbiotic behaviour and a metabolic
balance in the built environment would be the characteristics of such forms as
exists in the natural environment (Frazer 1995, 9).
Brief history of computation
In contrast to archetypal methods of retrospective briefs, this paper will give a
historical dialectic between two conceptions in computational design; complexity
and code. This is because complexity is the result intended and code is the way
which will bring us to have this end-result. These concepts are essentially two
characteristics of the language concealed in vernacular urban forms.
Until 1947 when Neumann and Goldstine established a definition for the term
coding: The organizing of a task into a series of steps and the translation of these
steps into a sequence of commands for a machine (Gramelsberger 2010, 30), the
worlds view for a code theory was a reference in religious terms.
After having a couple of evolution, the code theory was adapted as a biological
metaphor for an architectural concept by Eisenman in 1987. However, that was still
referring to the religious tradition of the codici in terms of a system that generates a
world view or when he operates and experiments with an instrumentarium of
information technology as a means of design strategy (Gleiniger and Vrachliotis
2010, 8).
Algorithmically coded
The code today is more likely to become an algorithmic term in architectural
application because it refers to as an evolutionary development rather than an

intuitional design strategy which never ended as complex as computational variety
but ironically could be more intelligent. In order to keep the intelligence as well as
manual methods, a programming language needs to have a fitness function which
helps select the more appropriate genotypes.
However this does not mean complexity unless the coded language allows different
kinds of contributions such as randomness, unexpected selections which exceed
human ability to explain. Or else, the solution would be a load of vacuous orders.
This is what happens in a real evolutionary environment.
In contrast, as criticised by Umberto Eco, what has been done so far in architecture
and simultaneously planning is to give form to previous solutions, which means
they are codifications of massage types (Dreyer 2010, 58). This specifically makes
a statement to which Western civilization has accustomed according to certain
statistical and dynamic criteria and certain rules of Euclidian geometry (Trogemann
2010, 52).
Euclidean geometry is used to generate the forms in intentional design approaches.
In computer logic designing is something entirely different, i.e., generating new
forms on the basis of algebraic and arithmetic operations. In contrast to the
geometry of conventional architectural design, which is based essentially on lines
and surfaces, algebraic forms of every kind are generated from one point and its
trajectory. In other words, the world is no longer narrated from the perspective of
the surface or the objects, but rather generated from a specific point
(Gramelsberger 2010, 36). This means a revolution in designing after the
Renaissance, of which painting, for instance, did entirely encapsulate facial value,
therefore forcing viewers to perceive only a captured image from the viewpoint of
the painter.
In fact, mathematical terms such as algebra and algorithm are not alien to the
eastern science, derived from eastern scholars names. If postulated, the eastern
historical cities must include answers affected by its glittering times math and
other realms of science. This will however be later referenced in more detail in the
context of the relationship between urban patterns and that of decoration found in
the medieval Islamic architecture.

Achieving an evolutionary model
Computational systems lack causal powers that would give then intentionality
which is necessary condition of thinking. Therefore, codified information simply
serves the purpose of conforming to functional requirements, yet do not guarantee
a successful design solution because of the lack of human involvement (Terzidis
2010, 85)
According to Frazer (1995, 65), the definitions of those that are bulleted below are
important factors to generate an evolution;
a genetic code-script
rules for the development of the code
mapping of the code to a virtual model
the nature of the environment for the development of the model
and most importantly, the criteria for selection.
Genetic code-scripting
Evolutionary design thinking is naturally tied to the importance of the algorithm: a
piece of code which takes instructions as an input providing answers that satisfy
stated conditions. This becomes very interesting if the algorithm is set to determine
the next possible result against given criteria, such as evolutionary algorithms and
their highly optimising subclass, genetic algorithms (Burry 2011, 79)
There are also different techniques of generating an evolutionary algorithm. In his
book, Coates (2010) compares two ways of genetic code-scripting; genetic
algorithm (GA) and genetic programming (GP). The results driven from these two
techniques have distinguishable features in terms of variation that is essential for a
complex language. Basically, two different things go on in an evolutionary
algorithm, one of which is the process of development and the other is the process
of genetics (Coates 2010, 95). The major difference between GA and GP is the way
of crossover step that also works in the natural world to differentiate the new
generations from their parents. Detailed explanations with figures will be presented
later on. Yet, to understand the difference between GA and GP, some figures
showing distinct means of generation elements are briefly displayed on the left
hand side.
Figure 6: Crossover in GA
Figure 7: Crossover in GP

According to Koza, GP may be well suited to a particular problem instead of GA if
one or more of the characteristics are a major part of a problem;
discovering the size and shape of the solution,
reusing substructures,
discovering the number and type of substructures,
discovering the nature of the hierarchical references among substructures,
passing parameters to a substructure,
maintaining syntactic validity and locality by means of a developmental
process, or
discovering a general solution in the form of a parameterised topology
containing free variables (Koza et al 2005).
The problem solving strategy of GP emulates the way of nature in which rules are
constant but the outcome varies according to environmental conditions. This leads
us to describe the process rather than the form. Only then, a more distributed
network, as described above by Alexander (1964), could be implied to see a
flexible result at the end. Apparently, GP is a much more capable tool to do so than
GA.


Chapter 2

The Solution in the Broad Context
COMPLEXITY AND RANDOMNESS


Complexity and Randomness
After the brutal simplicity of the modern architecture, Venturis critique in his
M.F.A thesis is seen as a starting point for the modern era to contemplate applying
the notion of complexity to design strategies. Complexity described by Venturi is
such that "there are properties of the whole which are distinct from properties of
the part. The whole composition may possess different degrees of articulation. The
more articulate the whole, the more does a change in one part effect the other parts
and the whole".
The description of complexity by Venturi is parallel to the way of how Derrida
explains why there is indeed no animal. According to him, all creatures have
distinct features therefore to a human-based separation is entirely wrong and the all
of them have distinguishable characters. It is a fact that organisms are radically
different from each other and to put all living things that are not human into one
category is a very violent gesture and theoretically wrong, which, in turn, engender
a ruthless consumption by human because of this conceptual simplification
(Derrida 2002). At present, a rather complex explanation of the whole life, namely
a holistic approach, is to lead the contemporary theories instead. Naturally, this
improvement in philosophy and all domains of the science gives rise to the
question in architecture and urban planning regarding complexity.
As architectural production is no longer the Marxist "us vs. them" dialectical model
of resistance (Meredith 2008), it is certainly in need of the movement from the old
to a new paradigm. It is touched above that such paradigm shift is the change of
basic assumptions, values, goals, beliefs, expectations, theories and knowledge. It
is about transformation, transcendence, advancement, evolution and transition.
While paradigm shift is closely related to scientific advancements, its true effect is
in the collective realization that a new theory or model requires understanding
traditional concepts in new ways, rejecting old assumptions, and replacing them
with new (Terzidis 2006, 59). The following sections will be leading us to
understand the relativity of the new computational methods to the way with which
primordial urban generations developed.
Surprisingly, the description of complexity leads us to randomness like the one in
vernacular urban fabrics that show an agglomerative growth. More interestingly,
Figure 8: Quasi-crystal
structure of Girih tiling that
is parametrically designed

the creation of randomness involves intention which is contrary to randomness. But
one cannot create randomness by definition, nevertheless, the maximum of
complexity is randomness (Terzidis 2008, 76). The inference to the randomness
peculiar to the vernacular urban forms in particular will be detailed after an
introduction to the urban pattern derived from decoration patterns as a consequence
of bottom-up approaches.

Bottom-up approach and complex Girih tiling
Under this subtitle, the strong relationship between the urban and decoration
patterns will be highlighted. This will help us understand a bottom-up methodology
in the context of a holistic approach.
In their work called the Girih project, Riether and Baerlecken (2012) seek an
answer the pattern-volume relationship. They find out that the volume emerges
from changing matching rules within a pattern, which shows a bottom-up process.
According to the Girih project, there is an intense relationship between texture and
massing in Islamic architecture. It recognises the way space is generated through
extrusion as an additional operation necessary to generate space, but alien to the
pattern logic (Riether and Baerlecken 2012).
Having used to be considered impossible, the discovery of quasicrystals by
Shechtman in 1982 brought about a paradigm change in chemistry, physics,
materials science and other areas of science and engineering. It was not an
invention because they have always been around without knowing about them
(Hargittai 2011). The characteristics of quasicrystals are found in Islamic mosaics
such as those in the Alhambra Palace in Spain. These mosaics, following
mathematical rules but never repeating themselves, have helped scientists
understand what quasicrystals look like at the atomic level (Nobelprize 2011).
These quasicrystalized patterns in medieval Islamic mosaics are called Girih which
means to interlock in Persian. The extraordinarily mathematical complexity in
these systemised art pieces had not been known in the western world until Roger
Penrose's discovery of quasicrystal tiling system in 1970s. However, such
involvement of this type of geometrical tiling, packing and covering in Islamic
Figure 9: Flower-like quasi-
crystals in aluminu-
manganese sample

architecture dates back to the 15th century. They are tiling systems that grow
unpredictably according to a specific set of rules but the pattern does not regularly
repeat (Riether and Baerlecken 2012, 4).
The proliferation of cities, systems of cities and their extended metabolic systems
across the world was characterised by episodic and irregular expansions and
incorporations, collapse and subsequent reorganisation in more complex forms
with greater flows of energy, information and material (Weinstock 2010, 177).
Combining this definition with the Girih tiling system in the medieval Islamic
architecture, a parametrically controlled architecture could be a suitable way to
manage to maintain the transmission of the information which is demanded by
complex systems in nature, biology, architecture and urban planning.
Does randomness mean richness?
When we see intriguing patterns of ant colonies' underground spaces, it makes us
eulogise their intelligence. However, technological occupation and its machinery
lifestyle, since the beginning of the 18th century, have brought about the distaste
for the vernacular urban forms whose main concern was human needs. In fact, the
reason lying under this modern arrogance is simply the notion that they did not
represent geometrically well-defined shapes. Yet, it has been revealed that they
carry the information to understand emergent growing in nature, therefore its
complexity, no matter how primitive and random they look.
In order to explain this randomness and complexity in pre-modern urban areas,
there have been emerging different explanations. Fractal dimensionality is one of
this. In the research about Venice, Crompton and Brown (2007) claim that Venice
is fractal because it can be seen to be composed of parts resembling the whole.
Essentially it was because the growth of the pattern in Venice followed a simple
way to arrive at a complexity in the total image.
Cansever (2011) attributes the complexity in vernacular urban forms to the first
result human relations as self-protection. Then the second phase is to come
together with someone else to act against possible dangers. According to him, cities,
throughout the history, were shaped by these essentials. The description of urban
formed in this way has similarities with the rules of random movements of the
'boids' - birds in New Jersey accent - which was put forward by Reynolds (1986).
Figure 10: A section of
urban fabric from
Marrakesh, Morocco
Figure 11: Axial maps of
Venice, canals and roads
Land&Canals
Land
Canals

There are three major behaviours for these flocking creatures; separation to have a
certain distance from others, cohesion to resist together with other nearby agents
and alignment to act together with others (Coates 2010, 89).
Although a historical urban pattern may seem randomly put, the pattern subsumes
many parameters which stand upon human intention lack of which escalates the
hesitation against computational design strategies. In this sense, computational
design methods suffer from the stigma of not sufficing permeability to allow
human intention. Yet, to understand the size of the complexity in contemporary
urban exceeds manual design techniques and entails well defined computation
strategies rather than formal formats developing in the name of so-called order.
Napoleonist, rich and top-down approach or random but bottom-up with full of
participation / Fractal strategy
Venice is a ubiquitous place which is an exception among European cities. It
symbolises an inclusive participation over the island networked with canals.
Ironically, Napoleon comes into the stage here again with a new urban form that is
conspicuously different style to the rest of Venice (Crompton and Brown, 2007).
As Napoleon is mentioned again, it is worth meeting one of the first celebrated
automata developed by Kempelen in 1770; the mechanical Turk (the Turk), a chess
playing machine. It was toured through the courts of Europe to amaze the
contemporaries of the Enlightenment, defeating many challengers including
Napoleon (Wei, 2006, 35). Although it was later revealed that the Turk was
controlled by master chess players, it was capable to solve the mathematical
problem of the Knight's tour which is a basic problem for computer science
students (Standage 2002, 30).
Having been interposed swiftly by a trivial section from the history of automata
leading us to the development of computation, we will deduce a necessary
approach from the description pointed out by Pearce. According to him, humans
successful fit into the built environment depends on the possibilities for change and
adaptation within a context of conservative resource use. Such possibilities are a
function of diversity and efficiency of form, and such diversity of form can
enhance mans relationship to his environment. minimizes the possibility for
diversity (Pearce 1978, xii).
Figure 12: The mechanical Turk

While fractals are a very useful tool for analysis, it does not seem to be promising
for a design strategy as an urban pattern generator. As put above, fractal designs
are one of the fully controlled means which produce only lots of rules whereas GA
and GP allow for closer results to the intentional complexity which is sought to be
achieved in computers. In other words, fractal design strategy does not suffice the
need of flexibility and permeability for designers during the process although its
self-reproduction results in complexity, which does, in this manner, tend to be a
vicious circle.
Randomness is shortly defined as chosen or happening without any particular
method, pattern or purpose. Instead of viewing order or randomness as two
separate, distinct and opposite states, to study the process of transition from one
state to the other is suggested by Terzidis (2006, 109). Only then the gap between
intentionality that can only be found on humans and ordering nature of
computation that is necessary for the actual amount of complexity can be filled.
Shape grammars and fractal generative systems
Influenced by the spread of biological and geometrical knowledge into different
realms, grammar based design patterns have abundantly been articulated. Having
been invented by Stiny and Gips (1972), shape grammars were mathematically
defined by Stiny (1980). Basically, the system comes from an initial shape to
describe a definition of existing designs. Shape grammars are descriptive tools up
until they are used as a set of automatic generation of designs. Despite the
considerable use of it in architecture, shape grammars are a new tool for urban
design, both for generative and analytical purposes (Beirao and Duarte 2005).
An interesting variation of shape grammars is that of fractal generative systems.
Based on a scheme, formulated by the German mathematician Von Koch, a fractal
process consists of an initial shape (the base) and one or more generators. From a
practical point of view, the generator is a production rule: each and every line
segment of the base is replaced by the shape of the generator (Terzidis 2006, 48).
A successful application of shape grammars is the experiment of Gozubuyuk et al
(2006) whose shape generative algorithm based on fractals for the early stages of
design is used to get information from an existing building and topography. This
work is classified as geometric-mathematical method which uses the scheme of
Figure 13: The Knight's Tour

counting squares to calculate the fractal dimension and which use computer
calculations for fractal simulation (Sedrez and Pereira 2010, 99).
Parametric urban shape grammars with genetic algorithms
Using the CityEngine system to generate an urban design, Parish and Muller (2001)
cascade the information about geographical sociostatistical image maps. This is
then followed by L-System road creation. The way they followed is thorough and
contextual. The result comes from contextual analysis and goes to solving urban
complexity. There are other attempts to use shape grammars in urban design, such
as Mayall and Hall's landscape grammar (2005) and more interestingly the work of
Teeling (1996) combining algorithms with shape grammars.
It is mentioned earlier in their research by Duarte et al (2007) that there is
possibility to incorporate shape grammars (Stiny 1980) with an existing generative
design system based on GA. The prototypical implementations of algorithms could
be seen as a set of linked activities (Coates 2010, 1).
It is very interesting that algorithms using only local forces can be found as a
complex organism at a long-range order. This produces interconnectedness
between the participants of the grammar. That is, in order to orient itself correctly,
each molecule has to know what is happening in far-away parts of the pattern
(Aranda and Lasch 2008, 197).
However, the suspicion is that the use of algorithms to address formal problems is
an attempt to overlook human identity and creativity and give credit instead to an
anonymous, mechanistic and automated procedure. In contrast, an algorithm is not
restrictive but rather a new domain of creativity (Terzidis 2006, 57).
On the other hand, parametric urban design is advised to be a complementary
relationship between the human mind and the machine rather than an arbitrarily
designed form for form's sake. And if the power of a parametric approach can be
implemented while still maintaining a low entry level, both economically,
technologically and in terms of required skills only then it would seem reasonable
to be designated as design tools in the realm of urban planning (Steino 2010).
Having mentioned weaknesses and strong points, this paper will now present a
more detailed version of suggestions under the subtitle of code-scripting. In doing

so, ways for pin-point accuracy for the strategy that will be followed, will be
purified, namely criteria for success.

Criteria for success
There are several threads in computational urban design. In the name of simplicity,
self-recursive systems could lead a designer(s) a decreasing complexity through the
end of the process. This is seen in GA in particular, with an offspring typology apt
to resemble more and more.
Throughout a programming generated such as GA and GP, natural selection plays a
key role. In order that natural selection should work, certain criteria must be
satisfied (Frazer 1995, 98):
i. The genetic information must replicate accurately.
ii. There must be an opportunity to generate variety and mutation (usually
achieved by genetic crossover and very small random errors in the genetic
copying).
iii. Any variation must also be capable of reproduction, and must occasionally
confer potential advantage when expressed as a phenotype.
iv. There must be massive over production of phenotypes.
v. There must be selective competition in particular environments (before
replication of the genetic code).
To summarize these criteria as different steps needed in a programming method,
main terms for an evolutionary algorithm technique could be listed as such, self-
replication, fitness function, crossover and mutation and feedback.
Self-replication
The essential feature of an evolutionary algorithm technique is self-replication that
is used in design methods such as cellular automata, fractals, GA and GP. If we
went earlier these, it might be referred to the Turing machine which is precisely
designated as the dawn of the idea of computational design. This machine allocates
0 and 1 infinitely, causing a great amount of information which could be infinite if

allowed. But what is sought for urban design tool is relatively an optimisation that
is managed.
A self-replicating code generated by GP techniques uses an identical copying
process which is ranged by mutations and feedback explained below.
Fitness function
Fitness function is crucially important for a programming to select the genotypes
that show compatibility with the parametric rules of the code. This step occurs only
once in GA on phenotypes whereas GPs applies an evolutionary pressure on
offspring as well as their genes. Such a way is one of the distinct features of GP
over GA while providing more variety. In terms of function both drive the input on
the same line though.
In the background, fitness function is theoretically supported by Darwins theory
referred to as survival of the fittest. The theory claims that the fittest individual
will maintain its life and hence being a part of the evolution. Although theorists
chase the concise form of the theory, it has been enhanced since its birth. Finally, it
has started to be exploited by computational design algorithms that could suggest a
new course for the theory.
Crossover and Mutation
Biological genes have been passed from generations to generations by means of
mutation and crossover leading an uncountable amount of variety that is increasing.
If there is a function responsible for the offspring differing from its parents, this is
because of crossover that replaces the genes. Mutation on the other hand is a very
small chance for further variety.
In GA, crossover is basically to pull two parts from the parents that are coded on
binary strings made of 0s and 1. In opposition to what GA causes with a close
similarity among offspring, that of GP, as genotype is tree-like, cuts branches no
matter how long they are and combine with the other couples. This allows for
individuals much further variety to their parents, simpler or more complex.
Feedback
As earlier compared to the way a GA-programmer follows, with GP, one puts the
phenotype under a constant pressure that is called evolutionary pressure. Resulting

in a plus variety, not only genotypes, carrying the information of individual
characters, but also phenotypes are actively manipulated by evolutionary pressure.
Having pointed out basic steps evolutionary algorithms, it can be claimed that GP
comes from GA which is a comparatively simpler explanation of the evolution.
On the other hand, in order to summarize the all essentials in a code that carry the
genetic information, we can first look to GA, as it is run in a similar way to GP,
with the elements and operations summarised from the book, written by Terzidis,
(2006) as below;
The Basic Linguistic Elements The Basic Operations
Constants
Variables
Procedures
Classes
Libraries
Arithmetical
Logical
Combinatorial
Relational
Classificatory

Attributes such as maximum number of individuals are represented by constants as
descriptive form of a population while variables could be taken in for parametrical
combinations. They describe some properties such as length, width, height, angle
and colour in the form of integer, float numbers or even strings that carry linguistic
information.
There is also a way to specify some parts of a code written under classes so as to
help user easily grasp and the code leave out the parts that are not implemented by
the code indeed. They can be called semi-autonomous entities in a code. Likewise,
libraries prompt the code to call functions automatically in order for the designer to
get rid of calculating everything from the scratch.
In principle, operations are types of works holding a set of functions, inducing the
elements already described. It is also worth mentioning that an initial population
created for a GP is a combinatorial programme that will end up with
aforementioned evolutionary pressure. For GA, this is not the case as it is
unnecessary for a binary string.
Table 1: Basic Elements
and Operations in coding

Chapter 3

The Specific Problem
LARGE-SCALE URBAN PROJECTS


Large-scale urban projects and high-rise shortcuts
"You never change things by fighting the existing reality. To change something,
build a new model that makes the existing model obsolete." Buckminster Fuller
From utopias to the most realistic urban design concepts, urban designs lack an
appropriate approach. Is it only a problem of the design world? In the meantime,
governing methods, legislation, bureaucratic requirements and regulations are all
responsible for this mess. None of models could be flawless but current planning
strategies need something new, a paradigm shift, because of the rigid and definitive
solutions. It is because of which gives birth to semantic problems with social
context that is so complex to design by manual skills.
On the other hand, there are worldwide cities growing massively. We often hear
different countries' growth rates fascinating economists. The demand to be
urbanised is to increase simultaneously but seeing a measured growing is hardly
ever possible. This is because of the thread put by the interest which is not merciful
for any delay, thereby causing a competitive atmosphere.
In this atmosphere, it is very difficult to find an innovative development on urban
design strategies. The more conventional the method, the faster and profitable the
process is. Though comparatively more developed, other parts of the world where
constant recessions hit the economies, too, have to keep going with what they are
accustomed to. Since urban areas changing very fast are horribly transformed from
a form to another one, any ideas regarding the cure for this anomaly should be
taken seriously.
Even though computational design is respectively in a faster improvement, it is still
far away from a paradigm shift. A paradigm shift in urban design means a means
for healthier next generations with enough elbowroom to exploit possible
opportunities which is not constraint by past and fast decisions. That is to say,
"build as you go, not overly for the sake of development ".
In order to understand the problem of this paper, a brief and deeper description, the
reasons making the conventional methods charming to be applied, and means of
solution will be sequentially carried out.

Mozart and complexity
In the movie of Amadeus (1984) set in Vienna, Mozart's music is described by
Salieri, played by Abraham whose jealousy leads him to a personal conflict
through the movie, as such "...Displace one note and there would be diminishment.
Displace one phrase and the structure would fall..." It is inferred by him that an
absolute beauty is hidden even in the drafts of Mozart, played by Hulce, while the
symphony no. 29 is heard in the background. Nevertheless, the drafts are composed
of fewer notes compared to that of Salieri.
Since the musical quality could be compared to the visual quality in our urban
areas, it might be a conclusion that an appropriate urban design entails contextually
responsive components. This highlights each individuals' identity which is absent
in current urban forms that use conventional approaches based on manual design
techniques. In other words, these methods produce virtually identical similarity and
an accurate uniformity though. In contrary, the richness found in Mozart's works
makes us recall the complexity from simple rules in algorithmic design which ends
in satisfactory variability.
In this part, the need for computational solutions in urban designs will be testified
by shortly putting forth large-scale urban projects whose primary implementation is
high-rise buildings.
(Re)developing an urban Mozart
The easiest way to redevelop a slum in an urban is to replace existing low-rise
pattern with high-rise buildings surrounded by fake green. High-rise buildings are
of a convenient process, providing same solutions in a short time for even a large
amount of demand. Although the circumstances of fast growing countries
necessitate such an easy strategy on planning, results are increasingly disconcerting
in terms of what a growth in nature expresses, such as individuality, discreteness
and identity (Terzidis 2008, 81).
Since the enlightenment which was as overwhelmingly sound as today's transitions,
fast growing and transformations of cities have become issues. In the museums in
the UK, it is pretty interesting to see neighbourhoods' models and simulations
displaying the change in the past 200 years. The harm given by the chaos produced

by fast growing has hardly been recovered and still requiring a lot of funding for
regenerating. The speed of growth is much higher in the technology era we all
experience though. Therefore, even the flexibility during planning is crucially
important because of the significance owned by each millisecond.
As mentioned above, the complexity demanded exceeds the ability of manual
design techniques that stacks high-rise buildings side by side for housing projects
in particular. This has been a fact across the world in which even developed
countries struggle to maintain with conventional approaches due to the cost of
complexity.
However, the emergent technologies of computation can obviate the necessity of
high-rise planning concepts in the name of low-cost solutions.
Before introducing the papers computational solution, large-scale urban projects in
China and Turkey will be scoped out to understand the causal factors for lack of
quality. The concern of this part will be mainly the paradox of high-rise buildings
which are repetitive but, in fact, not cost-effective in the long term.

China and Turkey: still far from Mozart
China and Turkey are amongst the fastest growing countries. Likewise, large-scale
urban regeneration projects are induced by desire for rapid development in these
countries. Giving a new shape to the society, usually its inadequate partnership,
large-scale projects are a highly complex instrument of local/central governments
and global companies. Therefore, large-scale projects are not only an urban
planning or architectural issue but more likely to be a domain of governance and
finance. As this part of the problem needs a considerable amount of space to
investigate thoroughly, the paper will just refer to this point in China's and Turkey's
cases in which the ways followed are similar, the scales implemented different
though. This way is called Neoliberal urbanism (He and Wu 2009; Bartu-Candan
and Kolluoglu 2011). The reason for setting the role governance here is to
understand the root of the factors causing conventional urban planning methods to
survive themselves.
Figure 14: High-rise housing
development, Hong Kong

Neoliberal urbanism and China
The rapid and spectacular transformation of cities induces highly sophisticated
complexity which is thought to be solved by non-state and quasi-state bodies rather
than central governments in neoliberal urbanisation (Wilson 2004; Peck and
Tickell 2002). Although, in China's case, it involves conflicts between neoliberal
practices and social resistance, neoliberalisation in China is a response to multiple
difficulties/crises and the desire for rapid development (He and Wu 2009).
The paper sees a similarity between China's urbanisation and Turkey's strategy
which is just a step behind the former as its super-fast development started
comparatively earlier. In terms of neoliberal urbanisation, Western exemplars turn
out discursive forms in China and Turkey because of the role of the local
government that has to deliver the policy of the central government (He and Wu
2009; Dincer 2011). A shift to decentralised forms of governance, first of all,
requires the externalisation of state functions, instead (Tasan-Kok 2010;
Swyngedouw 2005). This is because of the attitude towards the goal to be more
democratised. However, in China and Turkey, the process of neoliberal urban
development shows a different form than orthodox Western stereotypes, namely a
top-down approach to maintain fast development in a pre-mature market system
with strong state intervention (He and Wu 2009).
"We are building future's cities for the future of Turkey"
This saying embellishes the official website of Turkey's housing and development
administration (TOKI). There is no doubt that each project done by the TOKI
builds some people's future that may not be a positive point as the future articulated
comes. The main critique over the projects is that all the buildings are, almost
without exception, the same wherever they are. Although the demand for housing
projects was urgent before the TOKI took over the starring role nearly a decade ago,
it now seems to be the time for more comprehensive planning in Turkey for the
sake of its real future.
This is now clearer to understand why high-rise and large-scale urban projects look
attractive to the decision-makers. If this is the case, contemporary urban planning
needs a certain assistance of computational approaches such as parametric and
algorithmic urban designs. Even if not, highly complex demand for sustaining the
Figure 15: A high-rise
implementation of TOKI

(re)development of cities possesses urgency for a paradigm shift en-route to
computation.
While the flux of ideologies network into each other, thereby influencing
inconsistent methods, meanwhile, this amphiboly as used by Terzidis (2006, 105)
may result in a perforated stability after which creativity is innocently born. To this
end, let computation be helping form a new methodology.


Chapter 4

The Solution in the Broad Context
COMPUTATION FOR LIVEABLE URBAN


Computation for Liveable Urban
The definition of computational design is included in detail in the research by
McGill (2001), claiming that computational modelling, which is the representation
of a design, and computational design, which is the generation of design itself, are
for different purposes. The distinguishing features separating these two into
completely different categories give convincing answers to the critics of the use of
computers in architectural and urban design. Shortly, computational design is
creative, whereas computational visualisation which is dominant in architecture
and urban design, is restrictive.
There are two main objectives of this chapter that will focus on the computational
process of generating a flexible urban design tool. The first one is to decipher the
flowcharts of shape grammars, GA and GP. That is to say what order the
generation follows during the process. Another goal is to show how to integrate
optimisation techniques of GA and GP into shape grammars.

Complexity and shape grammars
Ironically, architects and urban planners often describes the complex forms of
vernacular products as primitive. The complexity presented by these forms invokes
a malfunction in the definition of itself because such complexity is thought to be
ungrammatical. Since it has been seen random, modern urban planning techniques
could not achieve to create a city as visually rich as the ones called irregular and
primitive. However, the reverse seems to be the fact as discussed in chapter four
with the inference of the decorative Islamic patterns. These Girih tiling patterns are
found to be existing in the form of urban texture. Following this, it could be
concluded that to claim a certain randomness on an artificial existence is in all
likelihood a wrong presumption in the theoretical background as more light is to be
cast on complexities every day.
Shape grammars were introduced by Stiny and Gips (1972) as generative design
logic as well as a descriptive tool. This paper suggests the use of shape grammars
as a descriptive tool to analyse the existing language to be followed and then as a
generative design logic relied on evolutionary algorithm techniques. The

geometrical solutions provided by shape grammars could be simply solved by
manual calculations but the complexity of the problem in large-scale urban projects
raised in this paper requires a computational arrangement which is also achievable
by hand in simple problems.
Generally, historically important cities are under the thread of new developments
and formal extensions. The historical downtowns with conventional urban planning
strategies are either to be transformed into unique places in which the natural
feeling of the city is missing or to be completely destroyed. Instead, the complexity
such cities present could guide new developments to keep the existing pattern
intact if analysed appropriately.
Why this paper proposes to use shape grammars is to assure a convenient design
technique with a robust base to pursue centenary rules of existing urban forms. In
particular, the urban planning strategies in fast growing countries urgently need
such an integration of the existing into the new proposals. Therefore, the new
context spanning from the past to the future could accommodate a variety of
identities so that the goal of diversity is achieved.
Literally grammars which can be visualised
With the shape grammars taken into this research, they are first appointed as the
descriptive language of geometrical forms. These formal codes could feature the
variables in the grammar describing geometries within certain shapes. Having been
analysed, the context with its constraints sorts out the rules to be parameterised. If
the process is bulleted successively, the outline would consist of two parts (see
Table 2):
1. Computational Design 2. Optimisation
Shape Grammars
Descriptive
Generative
Evolutionary Algorithms
Genetic Algorithms (GA) or
Genetic Programming (GP)

The first stage is to analyse and parameterise the rules by descriptive shape
grammars. Notwithstanding the two steps that are separated as grammar and
Table 2: Stages of
parametric shape
grammars with
optimisation algorithms

optimisation, the later pursues the former before prompting generative shape
grammar to find out possible end results. If the shape grammar were to be preceded
by its own generative rules instead of evolutionary algorithm search techniques, the
development of the grammar would be roughly classified as below (Halatsch et al
2008; McGill 2001):
Shape definition; defining geometry and attributes such as position,
Shape relations; arbitrary configuration of shapes and selection of rules,
Rule notation with shape operations such as placement and transformation,
Shape grammar
Design and element repository; the library of possible results.
However, what this paper will focus on is parametric shape grammars optimised by
GA and, later on, GP search techniques.
Shape grammars can be non-parametric or parametric. Parametric shape grammars
are needed to use the attributions defined in limits by the analysis in the context of
the existing site. This entails using variables instead of definitive shapes resulting
in less variety which is attempted to avoid for success for which a set of criteria
listed beforehand (Frazer 1995, 98). The more various solutions found, the more
successful the computational design is.
To achieve a parametric shape grammar, the flexible lot geometries, as illuminated
below (see Figure 16), could be applied versatile figures ranging in between two
constraints that are defined by the research conducted in the site which is proposed
to be extended.

Figure 16: The flow of
generating a flexible tool

Set grammars and parametric shape grammars
Having informed shape grammars, the paper will reference their practical
classification made in the work on the Marrakesh Medina (Duarte et al 2007),
explaining why to use set grammars that is a type of shape representation in shape
grammars. Although it seems that there is no certain theorem for the classification
of representations, the new approaches are to be added following the new types of
representation discovered in the computational design world.
Yet, there is an elaborate list of shape grammar implementations laid out by Chau
(Gips 1999; Chau et al 2004). The shortened version of this list that includes
mainly three types will be focused on under this subchapter. But there is something
worth mentioning in this list that the tools (see Table 3) used to generate shape
grammars range from AutoCAD/AutoLISP to C++. For the architects and urban
designers, there is no point straining too much to code a grammar in these
programming interfaces whose language suit better relatively to programmers.
Instead, it is suggested in this paper to use Processing that is also a programming
language for visual arts (Reas and Fry 2001). Having compared to AutoLISP by the
author, it is concluded that Processing which is simple yet powerful is
comparatively more user-friendly, promising to conform better to the domain of
urban design.
Name Reference Tool 2D/3D
1 Simple interpreter Gips 1975 SAIL 2D
2 Genesis (CMU) Heisserman 1991 C/CLP 3D
3 Shape grammar interpreter Krishnamurti 1982 2D
4 Genesis (Boeing) Heisserman 1994 C++/CLP 2D/3D
5 GEdit Tapia 1996 LISP [c]/Mac 2D
6 Shape grammar editor Shelden 1996 AutoLISP 2D
7
Implementation of basic
grammar
Duarte and
Simondetti 1997
AutoLISP 2D/3D
8
3D architecture form
synthesis
Wang 1998
Java/Open
Inventor
3D
9 Coffee maker grammar
Agarwal and Cagan
1998
Java 2D/3D

Table 3: A list of shape grammar
interpreters

When comes back to the classification, the computer implementations of shape
grammars can be simply divided into three groups based on the representation of
shapes. These groups could be listed as visual representation, symbolic
representation and set grammars in which shapes are treated like indivisible atoms
and represented as tagged data (Duarte et al 2007). First group recognises two-
dimensional space while the second is the implementation in three-dimensional
space. The third group of set grammars is restricted types of shape grammars in
which there are no emergent shapes and shape recognition (Wang and Duarte
2002). Therefore, set grammars could be sorted into a new category out of shape
grammars.
Set grammars are technically discrete elements constituting the vocabulary while
basic shape grammars comprise lines and points to create the vocabulary elements
(Cagdas 1995). The discreteness of set grammars allows parametric variables
oriented more easily, avoiding problems such as automatic shape recognition
(Duarte et al 2007).
With the use of set grammars, the urban design tool proposed is not designated to
some certain shapes recognised and transformed by the rules of the grammar. An
algebraic and arithmetic methodology is preferred to enhance the flexibility of the
tool, instead. Using Processing programming language that recognises points rather
than Euclidean geometries, the tool's flexibility performance would improve further.

In particular, concerning about the dissipation of already existing solutions could
be avoided. Generated by set grammars, a flexible urban design tool provides a
designer the chance of making required changes parametrically. Therefore,
spending too much time to make these changes could be out of concern.
Figure 17: Major shape
grammar interpreters

Shape grammars to be optimised by GA techniques
To generate the rules carried by the grammar, there are two principal approaches;
bottom-up and top-down. There is also a mixed approach which is proposed by
Duarte et al (2007). A mixed approach combines two approaches accordingly.
Then the solutions are selected by the eye of the designer who is able to change the
sequence of each approaches. Although it leads to interesting results, practical
problems occur while changing the operation from top-down to bottom-up or vice
versa. On the other hand, two more reasons persuade us to pursue the bottom-up
approach. One is the organic growth of the bottom-up which produces more
complexity. And the other is that it ends up with a maximum use of the
optimisation techniques of evolutionary algorithms (Duarte et al 2007).
Basically, shape grammars produce an acceptable amount of solutions to design
problems. GA and GP augment the population of satisfying solutions by
optimising parameters based on the grammar. In terms of spatial quality of space,
the cooperation between shape grammars and algorithms produces feasible
solutions thanks to the mind behaviour supplied by the algorithms. While shape
grammars work out formal problems, GA magnifies the variety and the amount of
optimum solutions.

To understand how these two process differentiate from each other, the illustration
is put below, presuming distinguishable effects in a real-time comparison.
Figure 18: Optimisation of shape
grammar rules by genetic
algorithms

Urban grammars and the Marrakesh example
In the rigorous work of Duarte et al (2007), shape grammars are required to analyse
an existing historical neighbourhoods that is called Marrakesh Medina (see Figure
19). Pointing out the character of the urban slice described by shape grammar rules,
a new development of an urban extension site is generated by GA.
Initially the bounding perimeter of the site is described (see Figure 19a). The edges
of the perimeter are drawn provided that they are not shorter or longer than a given
value. When we see how the boundary lines are produced from points it is not hard
to imagine a turtle in L-systems which symbolises the point moved by the users
commands.
Called derbs in the paper, the roads emerge from the entrance points randomly
settled on the edges (see Figure 19b). Then, the vectors depend on the rules of the
grammar are manipulated to drag these entrance points furtherly drawing the roads.
Other elements of the vectors are named as extenders, that are leading, and
articulators, that are described by the given conditions of the grammar. These
conditions consist of attribute variables such as angle and length. Subsequently put
along the inner roads, lots edges are organised and optimised to avoid overlapping
problem (see Figure 19c). Understanding lots and the way of placement in this
work help explore parametric urban shape grammars.
To satisfy all of these conditions defined by the shape grammar, GA is exploited to
avoid undesirable results such as overlapping lots. The method applied here is also
proved to be relatively more efficient than the shape grammars run without GA
optimisation.
Genetic programming (GP) vs. genetic algorithm (GA)
Greatly enhanced by Koza (1992), the method of GP is proved to be able to take
over the place of GA, particularly in terms of the variety it supplies. It is built upon
the principles of GA though.
It is important to highlight the differentiation between the phenotypes generated by
both ways. Created by GP techniques, phenotypes are under evolutionary pressure.
But GA implements no pressure on phenotypes. Given that GP commits much
more variety, this is mainly because of the evolutionary pressure on the phenotypes
produced. Dawkins calls the organisation of entire form creation, namely
Figure 19: The sample of
bottom-up derivation
Figure 19a
Figure 19b
Figure 19c
Figure 19d
Figure 20: Articulator (black
triangle) and extender (white
lane) in the Marrakesh work

genotypes and phenotypes, as a Body Plan. Coates accordingly states that GP
explores not only the space of possible designs but also the space of all Body Plans
(Coates 2010, 105).
On the other hand, the symbolisation of genotype and hence the distinct crossover
styles separate both methods. If recollected, GA is made up of binary codes,
whereas GP has got tree-like structure which slightly distinguishes the form of
crossover (see Figure 21). This leads GP to a great amount of information to be
carried because the operation should each time recognise if it has arrived at a
termination point on the tree. But GA does not have such a responsibility. This is
why, the risk of slower operations is the most serious drawback in GP comparing
to GA.

GP in Processing
This subchapter will summarise different programming examples in Processing
that is analysed to show the way to produce a GP coding. The examples were
provided from a web-resource that is created to help its user-community share their
sketches by the official website of Processing (OpenProcessing 2012). There will
be suggestions based on the empiric analysis of the Processing exercises that are
chosen according to the instructions taken from the Marrakesh Medina work
(Duarte et al 2007).
Figure 21: Differences
between GP and GA;
genotypes and phenotypes,
tree-like function generator
and crossover methods

In Processing, codes are written on the main part called Text Editor. Represented
by orange colour, the commands already existing in Processing defines the function
that Processing is wanted to prompt. The body of codes generally consists of three
parts; at the most top the definition and classification of values that will be
manipulated, next setup (void setup) and then draw (void draw) paragraphs.
Another thing that should be expressed is libraries accessed from the 'Sketch'
dropdown menu (Fry and Reas 2001).
As Processing tools to be exploited, the compliance of technical attributes of the
programme with GP's theoretical work flow defined previously is fundamental.
The dependence on the tools enforces the explanation of major elements and
libraries used in the programme. In essence, the scheme for the explanation
comprises of six parts in general in this paper; points, vectors, boolean operations,
combinatorial optimisation, parametric controlling and visualisation.
Points:
In Processing, there are several different geometrical elements available, such as
points, lines, curves and rectangles. But point command could be claimed as the
most suitable one in order for the set grammar to exploit vectors of the rules
more flexibly. As discussed earlier there is no shape emergence in set grammars.
It is therefore kept away from geometrical shapes until described by the
grammar based on the site analysis.
Figure 23: Drawing
point in Processing.

point(50,50);
Figure 22: Processing
programming language

To point out the positions of particles over time during a growth process, the
Traer Physics Library (2012) could be suggested to be downloaded and used for
GP, defining the elements of shape grammars. This library would pave the way
for creating particles leading the growth, applying real-like physical forces and
calculating the positions of them in the population at the same time. Imported
into the code as shown below, ParticleSystem command calls the rules of
library. Different values are then inserted to apply forces and directions on
particles.
import traer.physics.*;
ParticleSystem physics;
void setup() {
physics = new ParticleSystem( float gravityY,
float drag );
}

Vectors:
As the aim is to organise a computational growth of a grammar, vectors lead the
entire process through an algorithmic growth of points and lines. There is an
original vector command in Processing, which is typed as "PVector".
However, the calculations that the library of point2line provides is relatively
more applicable for the geometries in two dimension (Carlsen 2008). Yet, there
are other libraries doing the same work. So, the selection of the library depends
on a user's preference.
At below, there is how to import point2line library in order to specify the
number of vector after which direction of vectors could be valued.
import point2line.*;
Vect2[] vertices;
void setup() {
vertices = new Vect2[ number of vectors ];
}

In order to design an L-system growth that explains how GA and GP iterate,
Diffusion Limited Aggregation (DLA) could be inserted into the code. The
reason for this is simply because it is a vector-led and self-recursive growth like
L-systems that induced the development of algorithmic growth in computation
(Lindenmayer and Prusinkiewicz 2004, 16).
Figure 24: A section of
illustration by Living Net

Boolean operations:
GP functions terminates the growth at the end of each branches. The thing
which helps Processing recognise terminals in a GP code is boolean operations
working conditionally. For example, if boolean, namely true or false function, is
settled on 1, the process will maintain unless it is changed to 0.
boolean a = false;
if(!a) {
point( x, y );
}
a = true;
if(a) {
line( x1, y1, x2, y2 );
}

Above example shows that the code draws a point in the first condition.
Otherwise, a line will be drawn instead of a point.
Combinatorial optimisation:
Optimised by GP, the generation of shape grammars is made up of
transformation of geometries, such as move, rotate and scale. One of the basic
operations (see Table 1) is combinatorial optimisation of which the
methodology to solve is run by GP in the flexible urban design tool. More
importantly, Processing allows the combinatorial logic of transformations which
is also a part of an area in mathematics called linear algebra (Terzidis 2009,
187). As mentioned earlier, Processing inaugurates algebra in architecture rather
than Euclidean geometries. This is akin to the mathematics of evolutionary
algorithm techniques as well. And this is the main reason for the selection of
Processing language to write the coding effectively.
Parametric controlling:
To manage a parameterised coding, adding original controllers in Processing
would be adequate. Yet, preferably, other libraries named as GUI in Processing
language could be applied to the code as a class (see Figure 22) after which it
could be set up in the generator of the code in order to induce the class. Here,
the author will suggest the use of ControlP5 library as its graphics are mostly
used in architectural sketches in the web-resource and run more conveniently
(Schlegel 2012).

import controlP5.*;
ControlP5 cp5;
void setup() {
cp5 = new controlP5(this);
cp5.addSlider( name )
.setPosition( x, y )
.setSize( x, y )
.setRange( x, y )
.setValue( x )
}

As seen above, a slider could be easily positioned, sized, given a range between
two values and started from a value. There is a set of types of controllers whose
other attributes such as colour could also be altered.
Visualisation:
Sketches prepared in Processing primarily turns out to be on a two dimensional
Cartesian platform unless a camera for a three dimensional visualisation is put
in the code. PeasyCam provides a mouse-driven camera (Feinberg 2012).
Having been downloaded, it could be used by inserting the library as below.
import peasy.*;
PeasyCam camera;
void setup() {
camera = new PeasyCam(this, 0, 0, 0, 50);
}

Figure 25: GUI controllers
in Processing with
ControlP5 library

Conclusion
A PARADIGM SHIFT: LOOPING
FROM THEORY TO TOOL


Looping from theoretical urban design to an urban design tool
In terms of the objectives of urban design, there is no distinction between the urban
first ever described and presently handled. However, urban design should by no
means be taken as an isolated domain from a theoretical, perceptual as well as
philosophical background.
As urban design describes the way of life in a society, following a tolerant and
flexible scheme becomes substantial due to the complexity peculiar to fast growing
cities. In this work, such scheme is summed up as an open network design
approach which will allow necessary changes to be updated at the very instant they
are needed. Of a flexible urban design, the more immediate adaptation to the
changes within complexities brings feasibility to solve conflicts and contradictions
between different parties demanding different solutions.
The fractal analysis of vernacular urban forms exposes the rules of urban
complexities although they are commonly believed to be random generations
(Crompton and Brown 2007; Terzidis 2008). The researches on fractals in
vernacular urban spaces back the idea of following the rules of existing examples.
These examples proved to be visually qualified could be coded by shape grammars.
Computational solution in a nutshell
In theory, an urban design could be anticipated to respond to the every changes of
the nature in which urban life dwells. Without this, the presence of a sustainable
urban design could hardly ever be mentioned. These codes are available in nature
whose components are constantly responsive to one another for possible changes.
Considering this fact, an evolutionary growth process of a design tool is proposed
by this paper.
The proposed flexible urban design tool is named as 'quasiGrammars'. The
decisions taken during the prospective evolution of 'quasiGrammars' tool could be
divided into three sections; the decision to use shape grammars, to follow a bottom-
up approach and to utilise genetic programming rather than genetic algorithms.
With 'quasiGrammars' tool, the cooperation between shape grammars and
algorithmic techniques is designated to solve the complexity of urban design issue.
The result of descriptive shape grammars defines the geometrical features to be

applied, whereas genetic algorithms and genetic programming remarkably
accelerate the process of generating massive amount of optimum results.
In computer sciences and engineering, genetic programming optimisation has
recently started to be researched more commonly. But, in architecture and urban
design genetic algorithm is more frequently mentioned than genetic programming.
Comparing both, this paper concludes that genetic programming provides more
auspicious signs for a paradigm shift by being capable of carrying an extensive
amount of information.
Conclude with making a tool in Grasshopper
In order to start a genetic algorithm in a programming language, AutoLISP that is
the coding interface of AutoCAD was utilised at the beginning, ensuing the
analysis of the methodology in the Marrakesh Medina paper (Duarte et al 2007).
However, it is deduced that AutoLISP is hard to grasp the work-flow for a fresher
because of its limitations to generate the visualisation of the written text. The
author is experienced in AutoCAD though. Instead, Processing, which was initiated
by Fry and Reas (2001), is suggested to write an optimisation code and to input the
data of shape grammars.
With its user-friendly structure, Processing provides a convenient base for all
designers no matter how alien to the programming and coding field. The domain of
Processing varies from kinetic/physical visualisations to that of architecture. There
are also libraries that is very helpful for users to get rid of writing every necessary
codes from the scratch. What makes Processing more interesting is that it allows
the integration of texts and even visual results into other 3D modelling software
such as Rhino. This integration has recently lifted up original concepts to their final
forms in industrial, architectural as well as urban design.
It seems a reasonable assertion that a grammar language generating solutions for
versatile urban design problems can be easily exported from Processing into
Grasshopper as an optimisation and design tool. As long as the theorem of
computational design is kept intact in these tools, their output as a design tool
would exceptionally run useful solutions. Only then a step for a paradigm shift
could be taken.

Some of the advantages of the prospective 'quasiGrammars' tool could be listed as
below;
more comprehensive design solution for large-scale urban projects,
recordable urban design process instead of intuitive development, which
could result in reusable design patterns,
manageable complexity for complicated urban design problems,
discovery of new design patterns and geometries,
faster generation and visualisation of large-scale urban projects,
But there are threads of some downsides as well;
may come to an abrupt and end inadvertently,
may fuel unreasonable designs unless provided with practical applications
may end up with sluggish process due to the amount of information to be
carried.
All in all, with the growing concerns about urban design, the term of 'urban
grammars' (Duarte 2007) is handled in this work. The purpose is to generate a
flexible urban design tool based on parametric shape grammars that is optimised by
genetic algorithm and alternatively genetic programming. The potential of shape
grammars in urban design appears promising for designing flexibility and a variety
of solutions which are very hard to envisage by manual techniques.


References
Alexander, Christopher. 1964. Notes on the Synthesis of Form. Cambridge, Massachusetts
and London: Harvard University Press.

Aranda, Benjamin and Chris Lasch. 2008. "Out of Order." In From Control to Design,
edited by Tomoko Sakamoto, Albert Ferre and Michael Kubbo, 196201. Barcelona:
Actar-D.

Beirao, Jose N., and Jose P. Duarte. 2005. "Urban Grammars: Towards Flexible Urban
Design." Paper presented at the 23
rd
Conference on Education in Computer Aided
Architectural Design in Europe, eCAADe, Lisbon, Portugal, September 2124.

Bartu-Candan, Ayfer and Biray Kolluoglu. 2008. "Emerging spaces of neoliberalism: A
gated town and a public housing project in Istanbul." New Perspectives on Turkey 39:
546. Accessed July 7, 2012.

Burry, Mark. 2011. Scripting Cultures: Architectural Design and Programming. Sussex:
John Wiley & Sons Ltd.

Brown, F E and JH Johnson. 1985. "An interactive computer model of urban development:
the rules governing the morphology of mediaeval London." Environment and Planning
B: Planning and Design 12: 377400. Accessed August 15, 2012. doi:
10.1068/b120377.

Cansever, Turgut. 2011. Architecture and City in Islam. Istanbul: Timas Publishing. Kindle
Edition.

Chau, Hau Hing, Xiaojuan Chen, Alison McKay and Alan de Pennington. 2004.
"Evaluation of a 3D Shape Grammar Implementation." In Design Computing and
Cognition '04: 357376. Accessed August 15, 2012.
http://www.mech-eng.leeds.ac.uk/shape-grammars/papers/dcc04-19-chau.pdf

Chouchoulas, Orestes. 2003. "Shape Evolution: An Algorithmic Method for Conceptual
Architectural Design Combining Shape Grammars and Genetic Algorithms." PhD diss.,
University of Bath.

Coates, Paul. 2010. Programming.Architecture. New York: Routledge.

Crompton, Andrew. 2001. "The fractal nature of the everyday environment." Environment
and Planning B: Planning and Design 28: 243254

Crompton, Andrew and Frank Brown. 2007. "The double fractal structure of Venice."
Paper presented for the International Space Syntax Symposium, Istanbul, June 1215.

Cuthbert, Alexander Rankine. 2006. The Form of Cities: Political Economy and Urban
Design. Oxford: Wiley-Blackwell Publishing.

Dincer, Iclal. 2011. "The Impact of Neoliberal Policies on Historic Urban Space: Areas of
Urban Renewal in Istanbul." International Planning Studies 16: 43-60. Accessed July 6,
2012. doi: 10.1080/13563475.2011.552474

Dreyer, Claus. 2010. "Architectural Codes From a Semiotic Perspective." In Code: Between
Operation and Narration, edited by Andrea Gleiniger and Georg Vrachliotis, 5573.
Basel: Birkhauser

Duarte, Jose P. 2005. "A discursive grammar for customizing mass housing: the case of
Siza's houses at Malagueira." Automation in Construction 14, 2: 265275.

Duarte, Jose P., Joao M. Rocha and Gonalo Ducla Soarez. 2007. "Unveiling the structure
of the Marrakech Medina: A shape grammar and an interpreter for generating urban
form." Artificial Intelligence for Engineering Design, Analysis and Manufacturing 21:
317349.

Duarte, Jose P. and Jose Beirao. 2011. "Towards methodology for flexible urban design:
designing with urban patterns and shape grammars." Environment and Planning B:
Planning and Design 38: 879902.

Frazer, John. 1995. Evolutionary Architecture. London: Architectural Association
Publications.

Gips, James. 1999. "Computer Implementation of Shape Grammars." Invited paper
presented at the meeting for the NSF/MIT Workshop on Shape Computation, MIT,
Cambridge, Massachusetts, April 2526. Accessed July 16, 2012.
http://www.shapegrammar.org/implement.pdf

Gleiniger, Andrea and Georg Vrachliotis. 2008. "Editorial: The Complexity of
Complexity." In Complexity: Design Strategy and World View, edited by Andrea
Gleiniger and Georg Vrachliotis, 711. Basel: Birkhauser

Gleiniger, Andrea and Georg Vrachliotis. 2010. "Editorial." In Code: Between Operation
and Narration, edited by Andrea Gleiniger and Georg Vrachliotis, 711. Basel:
Birkhauser

Gzbyk, Gaye, Glen ada, and zgr Ediz. 2006. "Fractal based design model for
different architectural languages." In Game Set and Match II: The Architecture Co-
Laboratory on Computer Games, Advanced Geometries and Digital Technologies,
edited by Kas Oosterhuis and Lukas Feireiss, 280286. Rotterdam: Episode Publishers.

Gramelsberger, Gabriele. 2010. "Story Telling with Code." In Code: Between Operation
and Narration, edited by Andrea Gleiniger and Georg Vrachliotis, 2939. Basel:
Birkhauser

Halatsch, Jan, Antje Kunze and Gerhard Schmitt. 2008. "Using Shape Grammars for
Master Planning." In Design Computing and Cognition '08: 655673. Accessed August
15, 2012.
http://extras.springer.com/2008/978-1-4020-8727-1/Digital%20pdf/Halatsch.pdf

Hargittai, Istvan. 2011. "'There is no such animal ( )' Lessons of a discovery."
Structural Chemistry 22:745748. Accessed April 23, 2012. doi:10.1007/s11224-011-
9792-1.

He, Shenjing and Fulong Wu. 2009. "Chinas Emerging Neoliberal Urbanism: Perspectives
from Urban Redevelopment. " Antipode 41: 282-304. Accessed July 3, 2012. doi:
10.1111/j.1467-8330.2009.00673.x

Hensel, Michael, Achim Menges and Michael Weinstock. 2010. Emergent Technologies
and Design. New York: Routledge.

Hovestadt, Ludger. 2010. Beyond the Grid Architecture and Information Technology:
Applications of a Digital Architectonic. Basel: Birkhuser.

Krawczyk, Robert J. 2009. The Codewriting Workbook. New York: Princeton Architectural
Press.

Kwinter, Sanford. 2007. Far from Equilibrium: Essays on Technology and Design Culture.
Barcelona: Actar-D.

Koza, John R. 1992. Genetic Programming: On the Programming of Computers by Means
of Natural Selection. Cambridge, MA: The MIT Press.

Koza, John R, Martin A. Keane, Matthew J. Streeter, William Mydlowec, Jessen Yu and
Guido Lanza. 2005. "Problems for which Genetic Programming may be well Suited. "
In Genetic Programming IV: Routine Human-Competitive Machine Intelligence 5: 483
514. Accessed 8 September, 2012. doi: 10.1007/0-387-26417-5_16.

Lindenmayer, Aristid and Przemyslaw Prusinkiewicz. eds 2004. "The Algorithmic Beauty
of Plants." New York: Springer-Verlag. Accessed September 8, 2012.
http://algorithmicbotany.org/papers/#abop

McGill, Miranda Clare. 2001. "A Visual Approach for Exploring Computational Design."
MSc diss., Massachusetts Institute of Technology.

Meredith, Michael. 2008. "Never Enough." In From Control to Design, edited by Tomoko
Sakamoto, Albert Ferre and Michael Kubbo, 69. Barcelona: Actar-D.

Palma, Vittoria Di, Diana Periton and Marina Lathouri. 2009. Intimate Metropolis. Portland:
Routledge.

Parish, Yoav and Pascal Mller. 2012. "Procedural modelling of cities" In SIGGRAPH '01:
Proceedings of the 28th annual conference on Computer graphics and interactive
techniques 301308. Accessed on March 20. doi: 10.1145/383259.383292.

Pearce, Peter. 1978. Introduction to Structure in Nature is a Strategy for Design, xii-xvii.
Cambridge, MA: The MIT Press.

Peck, Jamie and Adam Tickell. 2002. "Neoliberalizing Space. " Antipode 34: 380404.
Accessed July 3, 2012. doi: 10.1111/1467-8330.00247.

Riether, Gernot and Daniel Baerlecken. 2012. "Digital Girih, A Digital Interpretation of
Islamic Architecture." International Journal of Architectural Computing 10: 112.

Sedrez, Maycon R. and Alice T. C. Pereira. 2012. "Fractal Shape". In Nexus Network
Journal 14: 97107. Accessed May 15. doi: 10.1007/s00004-011-0099-8.

Standage, Tom. 2002. The Turk: The Life and Times of the Famous Eighteenth-Century
Chess-Playing Machine. New York: Walker.

Stein, Nicolai. 2010. "Parametric Thinking in Urban Design: A Geometric Approach."
Paper presented for the 2010 ASCAAD Conference: CAAD, Cities, Sustainability, Fez,
October 1921.

Stiny, George. 1980. "Introduction to Shape and Shape Grammars." Environments and
Planning B: Planning and Design 7: 343351.

Stiny, George and James Gips. "Shape Grammars and the Generative Specification of
Painting and Sculpture." Information Processing 71 (1972):14601465.

Swyngedouw, Erik. "Governance Innovation and the Citizen: The Janus Face of
Governance-beyond-the-State." Urban Studies 42: 19912006. Accessed July 3, 2012.
doi: 10.1080=00420980500279869

Tasan-Kok, Tuna. 2010. "Entrepreneurial Governance: Challenges of Large-Scale
Property-Led Urban Regeneration Projects." Tijdschrift voor economische en sociale
geografie 101: 126149. Accessed July 7, 2012. doi: 10.1111/j.1467-
9663.2009.00521.x.

Teeling, Catherine. 1996. "Algorithmic Design: Generating Urban Form." Urban Design
Studies 2: 89100.

Terzidis, Kostas. 2006. "Algorithmic Architecture." Oxford: Architectural Press.

Terzidis, Kostas. 2008. "Algorithmic Complexity: Out of Nowhere." In Complexity: Design
Strategy and World View, edited by Andrea Gleiniger and Georg Vrachliotis, 7586.
Basel: Birkhauser

Terzidis, Kostas. 2009. "Algorithms for Visual Design Using the Processing Language."
Indianapolis: Wiley Publishing, Inc.

Trogemann, Georg. 2010. "Code and Machine." In Code: Between Operation and
Narration, edited by Andrea Gleiniger and Georg Vrachliotis, 4153. Basel: Birkhauser

Wei, Sha Xin. 2006. "Ethico-Aesthetics in T* Performative Spaces." In TRG, edited by
Times Up and FoAM, 2239. Brussels: FoAM.

Wang, Yufei and Jose Pinto Duarte. 2002. "Automatic Generation and Fabrication of
Designs." In Automaton in Construction 11: 291302. Accessed July 16, 2012. doi:
10.1016/S0926-5805(00)00112-6.

Weinstock, Michael. 2010. "The Architecture of Emergence: The Evolution of Form in
Nature and Civilisation." Sussex: John Wiley & Sons Ltd.

Weinzerl, Barbara and Ture Wester. 2001. "Quasi-Crystalline Geometry for Architectural
Structures." Presented at the IASS symposium, Nagoya, October 913.

Wilson, David. 2004. "Toward a Contingent Urban Neoliberalism." Urban Geography 25:
771783. Accessed July 3, 2012. doi: 10.2747/0272-3638.25.8.771

List of Websites

Carlsen, Carl Emil. 2008. "Point2Line Library for Processing." Accessed September 8,
2012.
http://sixthsensor.dk/code/p5/point2line/index.htm

Feinberg, Jonathan. 2012. "PeasyCam Library for Processing." Accessed September 8.
http://mrfeinberg.com/peasycam/#about

Fry, Ben and Casey Reas. 2001. "Processing Programming Language." Accessed
September 8, 2012.
http://processing.org/about/


Nobelprize. 2011. "The Nobel Prize in Chemistry 2011 - Press Release". Accessed March
17, 2012.
http://www.nobelprize.org/nobel_prizes/chemistry/laureates/2011/press.html.

OpenProcessing. 2012. "Web-resource for the Processing community to share sketches."
Accessed September 8.
http://www.openprocessing.org/

Reynolds, Craig. 1986. "Boids: Background and Update." Accessed September 8, 2012.
http://www.red3d.com/cwr/boids/

Schlegel, Andreas. 2012. "ControlP5 Library for Processing." Accessed September 8.
http://www.sojamo.de/libraries/controlP5/

Shiffman, Daniel. 2012. "Genetic Algorithms." Accessed September 8.
http://www.shiffman.net/teaching/nature/ga/

Traer, Jeffrey. 2012. "Traer.Physics Library for Processing." Accessed September 8.
http://murderandcreate.com/physics/

Web Presentation: Aydin, Serdar. 2012. "Quasi Grammars: An Algorithmic Simple-Ruled
Complexity for Generating a Flexible Urban Design Tool." Accessed September 8.
http://prezi.com/yphftc9wpedp/quasigrammars/

List of Videos

Derrida, Jacques. 2002. "Derrida on Animals. " Accessed September 8, 2012.
http://www.youtube.com/watch?v=Neu4kI_Yi0A

Cansever, Turgut. 2012. "Interview with Turgut Cansever. " Accessed September 8.
http://www.turgutcansever.com/ingilizceturkce.html


Appendix A
COMPLEXITY BY AUTOLISP -
GENETIC ALGORTIHM BY PROCESSING

Complexity generated in AutoLISP
Analysing the work of the Marrakesh Medina (Duarte et al 2007), the author
attempted to follow the same methodology until it was realised that the
AutoLISP language needs a stronger background in programming and coding.
The code was replicated from the book of Krawczyk (2009, 358-360) (see
References). The goal of this code is to use random function to design
complexity.
;----------------------------------------------
(defun rn (/ modulus multiplier
increment random)
(if (not rnseed)
(setq rnseed (getvar "date")))
(setq modulus 65536
multiplier 25173
increment 13849
rnseed
(rem (+ (* multiplier rnseed)
increment) modulus)
random (/ rnseed modulus)
)
)
;----------------------------------------------

;----------------------------------------------
(defun dtr (a) (* pi (/ a 180.0)))
(defun rtd (a) (/ (* a 180.0) pi))
;----------------------------------------------

;----------------------------------------------
(defun prog08a ()
(graphscr)
(command ".erase" "all" "")
; set start point
(setq pnt0 (list 0 0 0))
(prompt "\nprog08a:")
(setq xyside
(getdist pnt0
"\nEnter xy side:"))
(setq xtimes
(getint
"\Enter number x repeats:"))
(setq ytimes
(getint
"\Enter number y repeats:"))

(setq zheight
(getdist "\nEnter z height: "))
(setq nlevels
(getint
"\nEnter number of levels: "))
(setq cminx
(getdist
"\nEnter cube min size: "))
(setq cmaxx
(getdist
"\nEnter cube max size: "))
(setq angrot
(getreal
"\nEnter angle multiple: "))
(setq ntimes
(getint
"\nEnter number of random placements: "))
; number of placements
(repeat ntimes
; random location
(setq xoff
(* (fix (* (rn) xtimes)) xyside))
(setq yoff
(* (fix (* (rn) ytimes)) xyside))
(setq zelev
(* (fix (* (rn) nlevels)) zheight))
; centre of module
(setq pnt2 (list
(+ (nth 0 pnt0) xoff)
(+ (nth 1 pnt0) yoff)
(+ (nth 2 pnt0) zelev)))
; cube dimension
(setq cx
(+ cminx (* (fix (* (rn)
(+ (/ (- cmaxx cminx)
xyside) 1))) xyside)))
; rotation
(setq crang
(* (fix (* (rn) angrot))
angrot))
; draw cube
(command ".box" "ce" pnt2 "c" cx)
(command ".zoom" "e")
; rotate
(command ".rotate3D"
"last" "" "z" pnt2
(+ crang 0.0001))
)
; union cube
(command ".union" "all" "")
; slice at ground
(command ".slice" "all" "" "xy" (list 0 0 0)

(list 0 0 1))
; slice at sides
(command ".slice" "all" "" "yz" (list 0 0 0)
(list 1 0 0))
(command ".slice" "all" "" "zx" (list 0 0 0)
(list 0 1 0))
(command ".slice" "all" "" "yz"
(list (* xtimes xyside) 0 0)
(list 1 0 0))
(command ".slice" "all" "" "zx"
(list 0 (* ytimes xyside) 0)
(list 0 1 0))
; generate floor plans
(setq totalarea 0.0)
(setq totalperm 0.0)
(setq zelev 0.0)
(repeat nlevels
; get section
(command ".section" "all" "" "xy"
(list 0 0 zelev))
; move it
(command ".move" "all" ""
(list 0 0 zelev)
(list (+ (nth 0 pnt0)
(* (* xyside xtimes) 1.5))
(nth 1 pnt0) zelev))
; compute area
(command ".area" "o" "last")
(setq flrarea
(/ (getvar "area") 144))
(setq flrperm
(/ (getvar "perimeter") 12))
; acum floor and building surface
(setq totalarea
(+ totalarea flrarea))
(setq totalperm
(+ totalperm frlperm))
; inc height
(setq zelev (+ zelev zheight))
)
(command ".zoom" "e")
(princ "\nTotal area: ")
(princ (rtos totalarea 2 0))
(princ "\nPerimeter: ")
(princ (rtos totalperm 2 0))
(princ)
)
;----------------------------------------------

+5 secs +10 secs

+15 secs +30 secs


Genetic algorithm using Processing
Abondoning AutoLISP, the author started using Processing language which
seemed more user-friendly. The sample below will show a genetic algorithm
generation taken and analysed from Terzidis' book (2009, 172-177 ) (see
References). Here genetic algorithm will search the optimum solutions to make
the image mirrored.

int GA_POPSIZE= 300; //GA population size
int GA_MAXITER= 200; //maximum iterations
float GA_ELITRATE= 0.10; //elitism rate
float GA_MUTATION= 0.25; //mutation rate

String [] population = new String[GA_POPSIZE];
// array to hold possible solutions

int [] population_fitness = new int[GA_POPSIZE];
// array to hold the fitness value

String [] buffer = new String[GA_POPSIZE];
// a copy of population

int [] buffer_fitness = new int[GA_POPSIZE];
// a copy of fitness values

int esize = (int)( GA_POPSIZE * GA_ELITRATE);
//elitism size

String character = "";
// a dummy String used to create words

int w = 30;
//side of the bitmap (30x30)

int tsize = w*w;
//the size (length) of the
//target String

int iter = 0;

void setup(){

size(200,200);
// initialize the population: creates a number of
// random Strings

for(int i=0; i< GA_POPSIZE; i++){
character = "";

population_fitness[i] = 0;

for(int j=0; j< tsize; j++) // for tsize characters

character += str(int(random(2)));
//create a random String

population[i] = character;
}
}

void draw(){

background(255);

int i=0;

for(int x=0; x<w*5; x+=5)
for(int y=0; y<w*5; y+=5){
if(population[0].charAt(i)=='1'){
fill(0);
rect(25+y,25+x,5,5);
}
i++;
}
}

void keyPressed(){
// calculate fitness

for(int i=0; i<GA_POPSIZE; i++){

int k=0;

int pop_length = population[i].length();

for(int idx=0; idx<pop_length/2; idx++)

if(population[i].charAt((idx/15)*30+(idx%15))==
population[i].charAt((idx/15)*30+(30-idx%151)))

k++;

population_fitness[i] = (w*w/2) - k;

}
// sort them (simple bubble sort)
for(int i=1; i< GA_POPSIZE; i++)

for(int j=0; j< GA_POPSIZE-1; j++)

if( population_fitness[i] <
population_fitness[j]){
//swap values
int temp = population_fitness[ i];
population_fitness[i] = population_fitness[j];
population_fitness[j] = temp;
String stemp = population[i];
population[i] = population[j];
population[j] = stemp;
}

// print the best one
println( (iter++) + " Best fitness: " +
population_fitness[0] );

// mate take half of the population and cross it with
// the other half

int spos, i1, i2;
for (int i=0; i< GA_POPSIZE; i++) {
i1 = (int)(random(1.) * esize);
//random position within the elite population

i2 = (int)(random(1.) * esize);
//random position within the elite population

spos = (int)(random(1.) * tsize);
//random position of character within a String

buffer[i] = population[i1].substring(0, spos ) +
population[i2].substring(spos, tsize);

// crossover
// mutate: take a string and alter one of its
//characters
if(random(1.) < GA_MUTATION) {
//if chance is 1:mutation rate

int ipos = (int)(random(1.) * tsize);
//select a random character


character = "";
for(int j=0; j< tsize; j++)

if( j== ipos)
character += str(int(random(2)));
//replace a random character in the String

else
character += buffer[i].charAt(j);
}
buffer[i] = character;
}

//for
// swap buffers

for (int i=0; i< GA_POPSIZE; i++) {
population[i] = buffer[i];
population_fitness[i] = buffer_fitness[i];
}
}

// key pressed

1st generation ~10st gen ~50th gen

~100th gen ~150th gen

quasiGRAMMARS Submition

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

quasiGRAMMARS Submition

Uploaded by

Copyright:

Available Formats

Serdar Aydin

A Parametric Quasi-Grammar for Generating a Flexible Urban Design

You might also like