Introduction
This paper presents IM-sgi – model of interface for shape grammar(s) (SG) implementations. The model illustrates the existing lack in the use of SG for architectural and design projects. Since the presentation of SG (Stiny & Gips, Reference Stiny and Gips1975), there are a considerable number of computational implementations, but few actually assist in the use of SG in the design field (Yue & Krishnamurti, Reference Yue and Krishnamurti2014). SG is defined by a vocabulary of shapes and a set of rules that specify how to combine such shapes by recreating spatial relations defined between them (Stiny, Reference Stiny1977). These are similar to phrase structure grammars, with an alphabet of shapes that generate one-dimensional (1D) to n-dimensional shapes. SG use algorithmic processes for the representation and computation of shapes that organize specific knowledge for the exploration of designs (Krishnamurti, Reference Krishnamurti1980).
The use of SG with computer applications enables the designer to take the full advantage of (1) synthesis and analysis of styles in design/architecture/art and (2) the creation of new forms. Several models of interaction with the user have been developed, as the ones developed by Scott Chase (Chase, Reference Chase2002) and Haldane Liew (Liew, Reference Liew2002) [see analysis in (Tching et al., Reference Tching, Reis and Paio2016)]. These models seem to lack guidelines for a clear and efficient interface for SG implementations that translate the objectives of the existing models of interaction. The interface of SG implementation should take into account architects/designers who are trained and comfortable using CAD software systems – an interface well adopted and stabilized.
The complexity of CAD systems and the types of tasks associated with them require a high-quality interface. In this sense, the best way to ensure that SG implementation is well accepted and understood by an architect or designer is to include the basics of the user. IM-sgi aims to provide computing ergonomics and suitability to architects to work with SG implementations. It uses human–computer interaction (HCI) methods, with a focus on those for interactive design. Thus, the main focus is on user experience while using an application, addressing the usability problems in the process of design interface, with emphasis on cognitive and experiential factors.
In resume, this paper has two sections. The first addresses the need to move toward the use of SG by architects and designers, and the second presents IM-sgi, a model of user interface (UI) developed according to the principles of HCI. IM-sgi proposes that a well-focused interface will allow designers and architects to clearly understand SG implementations and their potential use in daily design practice.
Toward an effective use of SG
Digital design and CAD applications are widely used today in architectural projects and design. As far as creative areas are concerned, computational applications have meant much faster and more effective processes, as compared with those previously done. They have also allowed the production of more complex and ambitious projects, offering new ways of analysis, control, and representation that would not otherwise be available to designers, as more time and unaffordable resources would be required. Architectural projects, in contrast to other artistic areas, develop in different phases that can be described not only as a need to solve a large number of issues but also as the fulfillment of rules and constraints, whether they are legal, environmental, economic, or formal. It is the solution of all these issues that the final project comes out, and the architect shows his/her creativity, combining all the items in an aesthetic and functional product. Dividing the project into its elementary parts, we see that the architect elects, consciously or intuitively, a set of rules and makes choices that impact the final work (Tching et al., Reference Tching, Reis and Paio2013).
Overall, the architect's intentions are guided by rules that are imposed by technical and legal needs of the project and by the artist's aesthetic and creative intentions.
It is common practice to use computational applications that reproduce the architect's manual design, and other technical aspects of a project (such as automatic measurements, thermal simulations, 3D visualization, etc.). However, to support earlier conceptual project stages, there is a demand for new CAD solutions that do not focus on the development of shapes and structures already well defined (McKay et al., Reference McKay, Chase, Shea and Chau2012). It will be possible for the designer to use SG implementations in their common practice with new systems that need to support the designer's creative process, offering non-obvious design alternatives that were not originally defined by the designer and can be used as a solution or as a creative stimulation for new ideas. The use of SG implementations can lead to the optimization of ideas, taking advantage not only of CAD but also computational creativity (CC). The solutions given by SG implementation reflect a creative process of synergy between SG and the designer (McKay et al., Reference McKay, Chase, Garner, Jowers, Prats, Hogg and Lim2009). This can potentially improve, provide uniqueness, or at least an alternative from what the architect/designer would accomplish without the use of SG.
The communication between the designer and the computational generating system is defined by the computational interface. In the creation of a computer application, the interface is a time-consuming task, and many times the programmer, or program designer, is not familiar with the true needs and limitations of the end-user. A model that specifies categories of SG users and their objectives, and that clarifies how each type of user will make use of SG and what barriers of communication need to be addressed will increase the possibilities of the success of computer SG implementation use. So, how to achieve good usability? According to Myers, there are three main points. First, know the users and their tasks through the analysis of these and contextualized investigations; second, ensure the adequacy of the design through prototypes tested by users with a participatory and iterative design; third, make the final product usable and efficient through the use of the interface, analyzing it through various methods, heuristics, and others (Myers, Reference Myers2008).
The design of the UI is a creative process and often designers have difficulty thinking like end-users. The usability is linked to learning, efficiency, productivity, ease of memorization, satisfaction, and no errors. Good usability is important, as it reflects the notion of quality of the user's system. Good usability allows beginners to become effective more quickly, experts more efficient, and a reduction in errors. The true needs have been identified so that the application will be successful on the market (Myers, Reference Myers2008).
IM-sgi: interface model for SG implementations
In section “Toward an effective use of SG”, we showed that the interface is very important for the success of SG implementations, as it is the means of communication between the computational tool and the designer's goal. For that reason, IM-sgi is based on the analysis of the interaction model developed by Scott Chase (Chase, Reference Chase2002).
Ultimately, a computer system is created for the function you want to perform, and the functionality of a system is defined by the set of tasks for its user (Karray et al., Reference Karray, Alemzadeh, Saleh and Arab2008). As the user meets his/her objectives when using the system efficiently, the value of the application is visible.
According to (Lewis & Rieman, Reference Lewis and Rieman1994), the process to be followed when creating a new interface that focuses on the success of the task performance has the following steps:
1. Analysis of the target users and the tasks they will perform with the application;
2. Selection of the main tasks the application must perform;
3. Analysis of existing interfaces of similar applications;
4. Initial definition of the interface;
5. Evaluation of the interface proposed without users (by the designer of the interface or experts in the area);
6. Prototyping;
7. User test;
8. Iteration of prototype corrections;
9. Final development of the interface.
This process for a good interface definition requires a significant amount of time, but time is often scarce when a new application is being developed. This might be one of the reasons why existing SG applications, which require such complex development of algorithms and programming time, still have rudimentary interfaces, as analyzed in our previous work (Tching et al., Reference Tching, Reis and Paio2016). This acknowledgment is the basis of our IM-sgi proposal. Together with IM-sgi, an interface model for SG implementations, we collected information for stages 1–3 and gathered the criteria needed for the development of stages 4–6, thus guiding the creation of SG interfaces with high levels of performance in terms of usability. The compilation of all this information in an interface model for SG implementation allowed us to develop and focus on the development of the application function. We then rapidly created an interface prototype following IM-sgi criteria that has all the needed considerations to be adjusted to SG users, allowing them to perform the tasks needed to work with SG. Following the Lewis and Rieman's process of nine stages listed above (Lewis & Rieman, Reference Lewis and Rieman1994), IM-sgi definition of stages 1–3 has already been developed and presented in a previous article (Tching et al., Reference Tching, Reis and Paio2016).
In this paper, we present the criteria we developed based on ergonomic and usability standards. We applied these to SG tasks that can define good interfaces for SG applications. The vision here is that, with the correct interface, SG could be adopted by architects/designers in their project practice who can then take SG to the professional field, instead of staying only in the educational one (Tching et al., Reference Tching, Reis and Paio2013). The first step was to understand the types of users that would be using SG and what tasks they would need to be able to perform. For this definition, Scott Chase developed an important model of interaction for SG systems (Chase, Reference Chase2002). It addresses the types of SG users and the different ways they can relate to the SG applications, pointing out different scenarios that range from a higher control for the user of the system to a higher automation and passivity of the user. Studying these control scenarios, with the aim for architects and designers to be able to use SG in creative projects, we defined three groups of users for the IM-sgi, according to their level of control of SG and their needs for manipulation: students, designers/artists, and SG experts (Tching et al., Reference Tching, Reis and Paio2016).
The general criteria of IM-sgi consider these users in a global form. It then defines a series of specific criteria for the three levels of expertise. Thus, the same interface can evolve according to the progress of the user expertise with the SG implementation, but keep the same ergonomic criteria (EC) and usability performance. To develop stage 2 (selection of the tasks the application must perform) and stage 3 (analyzing existing similar applications), the use of an inspection method in the field of HCI was applied: the cognitive walkthrough (CW). This method allowed the clear definition of the tasks that SG users should be able to perform if these tasks are successfully achieved in a group of existing SG implementations that we selected to be tested. The authors presented the full development of the CW in (Tching et al., Reference Tching, Reis and Paio2016).
The conclusions of the CW allowed us to understand the interaction fragilities common in SG implementations that should be addressed by IM-sgi. The main one is the importance of the use of a graphical-user interface (GUI) that allows the permanent visualization of the shapes manipulated. As SG are mainly visual, as are most of the strategies used for early stages of creative projects, the graphic illustration of SG elements and results are essential to our investigation. The clear guidance to the user through the process of shape and rule creation must also be guaranteed so that SG can be created with success. The interface will then be self-explanatory and allows the user to create SG, focusing on the tasks to be performed, rather than concentrating on interpreting how windows, menus, and commands work.
IM-sgi criteria
IM-sgi defines the criteria that the interface for SG implementations should satisfy. Why should we have a specific model for these interfaces and not just follow general guidelines? Because it is not possible to define generally what a good interface is. This is dependent on the tasks to be performed and the users who will manipulate the interface. As stated before, usability measures the quality of the interface elements related to their usefulness. According to (Nielsen, Reference Nielsen1994), usability is a quality attribute that allows the understanding of how easy UI is to use. To continue developing IM-sgi, after understanding the needs of the users, the next step is to define the criteria that will guide the interface to good usability. To achieve this goal, we gathered existing criteria to evaluate usability and ergonomics of the interface and interpreted them as keys that will be clearly defined by the model of interface. We then applied it to the tasks the user will need to perform in an SG implementation.
Since the development of HCI, countless authors have developed several general design guides, sets of guidelines, checklists, standards, and heuristics in order to help achieve good UI (Bastien & Scapin, Reference Bastien and Scapin1995). Some examples are standards such as ANSI, DIN, and ISO, design guides from (Scapin, Reference Scapin1986; Schneiderman, Reference Schneiderman1987; Ravden, Reference Ravden1988; Brown, Reference Brown1998), sets of guidelines from (Bodart & Vanderdonckt, Reference Bodart and Vanderdonckt1995) and (Smith, Reference Smith1986), style guides from (IBM, 1989) and (Apple, Reference Apple1992), and heuristics like those from (Molich & Nielsen, Reference Molich and Nielsen1990; Scapin, Reference Scapin1990; Bastien & Scapin, Reference Bastien and Scapin1993; Nielsen, Reference Nielsen1994). Despite the specificity of each set of guidelines, the main aspects of usability are learnability, memorability, low ratio error, efficiency, and satisfaction. This means that HCI has been sharing a path with cognitive theories that also focus on reducing the memory load from the user (Hollender et al., Reference Hollender, Hofmann, Deneke and Schmitz2010). Also, both areas acknowledge the importance of the learner characteristics, showing that, to a certain extent, cognitive concepts and HCI approaches have been integrated.
Bastien and Scapin recognized the limitations and difficulties in evaluating an interface, using any HCI approach individually. So they proposed a set of EC for interface evaluation (Bastien & Scapin, Reference Bastien and Scapin1993) that intends to be a compilation of the several existing guidelines, making their criteria very specific and oriented to avoid misinterpretations. The term EC shows that the authors were interested in the adequacy of the criteria to the users’ characteristics, behaviors, and needs. Bastien and Scapin also developed a consistent model of testing these criteria to validate their adequacy, since the existing guidelines and heuristics from other authors have not applied them (Bastien & Scapin, Reference Bastien and Scapin1995). These criteria have also been developed for use in different types of interfaces, such as virtual reality environments (Bach & Scapin, Reference Bach and Scapin2003).
As the purpose of IM-sgi is to gather the correct criteria for a very specific type of interface (SG implementation interface), Bastien and Scapin's EC was the basis to define IM-sgi criteria, together with the knowledge gained with a CW made with existing SG implementations and analysis according to the ISO standards (Tching et al., Reference Tching, Reis and Paio2016).
By converting these evaluation criteria to define successful interfaces for SG implementations, IM-sgi demonstrates how each criterion should be addressed for a specific SG task so that the steps needed are successfully communicated by the interface. So, instead of general guidelines, IM-sgi clearly defines how the interface should communicate with the user in each task to be performed while working with SG. Bastien and Scapin defined 18 EC that are organized into eight main sections. For the definition of IM-sgi, Bastien and Scapin's criteria have been interpreted as guidelines and transformed into IM-sgi definition criteria. IM-sgi criteria, although based on Bastien and Scapin's EC, are presented in a different order. [For IM-sgi guidelines to the SG implementation developer in the interface definition, see (Tching et al., Reference Tching, Reis and Paio2016).] IM-sgi criteria create specific definitions for how the interface should look to guide the user through the main tasks to be performed while working with SG (see Table 1 below). These five tasks were defined for and subsequently validated by the CW of a previous investigation (Tching et al., Reference Tching, Reis and Paio2016). In the previous analysis, the main tasks the users will perform were defined according to a hierarchy of tasks that the user will take to create and use an SG. These tasks are described in Table 1.
Table 1. Compatibility
In summary, each IM-sgi criterion is divided into six groups of guidelines, one group of general guidelines and one group of guidelines related to each of the above tasks. The three types of users and interaction modes that the interface must consider are:
• Students–GUI mainly with drawing tools available and with immediate visualization of any action made. This interface should be prepared for a reduced control of the user over the implementation, which will give SG results in a more automated way. This will be considered a Beginner Mode.
• Artists/designers–GUI with drawing, editing, and exporting tools that follow conventional CAD software, allowing the user to have a good control of the implementation. They can then use it with possible integration with other CAD software so that SG can be defined to solve design projects, and its results can be used for further design project development/detailing. Command lines can be used to help the user clearly define the Rules of SG in order to use SG for specific problem solving (Tching et al., Reference Tching, Reis and Paio2013). The user control should be higher and the degree of automation should be less than in the Beginner Mode, as this is an Intermediate Mode.
• Experts in SG–GUI combined with programming tools that allow the user to have full control over the implementation. They can even change its code so that it can create SG in new or different ways. Command lines or even windows dedicated to programming can be used. The user shall have full control over the application with a reduced degree of automation, as this is an Expert Mode.
Following the above descriptions of Bastien and Scapin's EC, target users, and task types, IM-sgi is presented here with the description of the original EC and the adaptation for IM-sgi criteria in the tables. It is important to notice that IM-sgi criteria were defined so that they can be applied to any type of SG implementation, although not addressing directly all the features that the implementation shall have. The idealized general SG implementation characterization made by (McKay, et al., Reference McKay, Chase, Shea and Chau2012) points to seven requirements (form, orientation of shapes, semantics, definition interface, usability by designers/intuitive UI, automatic subshape detection, clear interpretation of resulting designs). Our model focuses on the definition interface and usability by designers with guidelines for these specific requirements. The criteria in IM-sgi can address different types of generation processes that can be applied to the several actions that the interface must allow for a specific SG implementation. Taking the generation process presented in (Trescak et al., Reference Trescak, Esteva and Rodriguez2012), several input parameters can be introduced to manipulate an SG, for instance, choosing the number of iterations, applying step-by-step iterations, and generating a list of possible next shapes to be chosen and the use of markers. For expert users, our defined criteria can provide different ways of defining rules, either by graphic shape rules or mathematical rule schemata (Economou & Kotsopoulos, Reference Economou and Kotsopoulos2014).
In summary, we developed IM-sgi with a total of 259 criteria, divided according to the 18 EC that Bastien and Scapin developed (Bastien & Scapin, Reference Bastien and Scapin1993) described in Tables 1–18.
Table 2. Adaptability – users’ experience management
Table 3. Adaptability – flexibility
Table 4. Significance of codes
Table 5. Consistency
Table 6. Immediate feedback
Table 7. Guidance – grouping and distinction of items by location
Table 8. Guidance – grouping and distinction of items by format
Table 9. Guidance – prompting
Table 10. Guidance – legibility
Table 11. User workload – brevity – concision
Table 12. User workload – brevity – minimal actions
Table 13. User workload – information density
Table 14. Explicit user actions
Table 15. User control
Table 16. Error protection
Table 17. Quality of error messages
Table 18. Error correction
These 18 EC groups provide very specific guidelines for an interface creation, explicitly defining how the interface communicates with the user through the tasks he/she will be performing for good usability. Every EC leads to the definition of six groups of criteria, one group with general guidelines and five groups according to the tasks previously defined. All criteria focus on assuring that the interface clearly guides the user on the actions he/she should perform to do the tasks and also guides him through the correct order of steps to successfully create and manipulate SG. The next stage of this investigation will be to use the criteria to define interfaces for SG implementations. According to [(Lewis & Rieman, Reference Lewis and Rieman1994) referred to in section “IM-sgi: interface model for SG implementations”], we now have steps 4 and 5 completed and presented in a paper under development.
IM-sgi application
Application of the IM-sgi criteria is needed to verify if the definition of suitable interfaces for SG implementations is accurate. Depending on the importance and complexity of interface design, many tools are available to make interface prototypes prior to the application development. Prototyping unveils and explores human needs. In the information technology (IT) market, prototyping helps both the client and the designer/developer to understand each other's requirements. The prototype plays a major role in giving clarity to a client who does not have prior IT experience. This initial, raw presentation of an interface has been named low-fidelity prototyping (Rudd et al., Reference Rudd, Stern and Isensee1996). Unlike high-fidelity prototyping, this method requires less time and fewer specialized skills and resources. Its purpose is not to impress users, but to learn from them. The goal of low-fidelity prototyping is not connected to a client/programmer negotiation but has the users as its main focus. In a way, the low-fidelity prototyping technique facilitates listening, rather than selling. It opens a conversation in which users’ needs, designers’ intentions, and other stakeholders’ goals are discussed and aligned.
In order to be able to test and validate IM-sgi in this investigation, we developed a low-fidelity prototype, so that we could analyze IM-sgi criteria before testing with real users and with a real SG implementation development. This prototype translates visually what IM-sgi criteria define – one of many options possible. For our purposes here, this simple prototype was defined for 2D SG, as this type of representation is adequate for the purpose of using SG in the architectural practice. Although architecture is a 3D area, 2D representations of shapes can have multiple meanings. The clarity of 2D plans remains the primordial architectural representation (Ligler & Economou, Reference Ligler and Economou2015). Thus, 2D SG are adequate for creative exploration in this field.
SG implementation interface prototype
To calibrate the level of expertise of the users, IM-sgi was developed for the three types of users described in section “IM-sgi criteria”. In the prototype created, a landing page, shown in Figure 1, is proposed to make the user choose the level of expertise that he/she believes better suits his/her SG knowledge. The name of the different expertise levels follows the level of expertise of the three types of users defined above. The choice of each level will originate the loading of the interface that should communicate the user's characteristics. Another option for this differentiation of the interface according to the level of expertise could be chosen, that is, a predefined interface could be loaded automatically, and then it asks the user if he/she would like to use a different one.
Fig. 1. SG Welcome Screen.
The screen in Figure 2 below shows a GUI according to the IM-sgi criteria SG-COMP (see Table 1), representing the users’ characteristics. As the interface is directed mainly for the users of design areas, a GUI that resembles existing CAD software will be easier to be understood and accepted by this group, as stated by the IM-sgi criteria SG-FLEX-FEED.
Fig. 2. SG Beginner Mode screen.
Three drawing windows are shown according to the IM-sgi criteria SG-FLEX (see Table 3) and SG-SICO (see Table 4). The windows are numbered and named according to the IM-sgi criteria SICO (see Table 4), SG-GDLO (see Table 7), and SG-PROM (see Table 9). The first task for the beginner is to define the Initial Shape. In this level of expertise, a toolbox with shapes is shown so that the user may drag them to the Initial Shape window, according to SGSC-USEX-A (see Table 2) and SGSC-GDLO-B (see Table 7). When the user manipulates a shape by drag and drop, the Rules window will update in real time, as all the other windows, showing the shape to be used as the basis for Rule definition. This function enables the users to get an immediate, real-time response to their actions. In the Beginner Mode, the use of messages indicating user steps is desirable. This mode may play the role of a tutorial for the use of the application (see Tables 1–18 for competing explanation of criteria abbreviations).
The Rules window is the second one to be used, after the Initial Shape window, according to SGRC-USEX (see Table 2) and SGRC-GDLO-A (see Table 7). A toolbox with a group of Rules is graphically shown for the selection of rules from previously saved ones, or predefined by the application, is shown below the Rules window. This is called the Rules List, according to SGRC-GDLO-B (see Table 7) and SGRC-GDLO-C (see Table 7). The use of the SG is made by selecting the iterations number. A number can be predefined to allow a solution to appear immediately as the Rule is created, according to SGAPP-USEX (see Table 2). As the SG is applied, a number of alternatives will be shown in the Other Results tool bar. These can then be selected for work in the SG window, according to SGALT-GDLO (see Table 7). Generally, all criteria that can be verified by a graphic prototype were considered, except error management.
In our prototype, the Intermediate and Expert Modes follow the same organization as the Beginner Mode. The Intermediate Mode is for artists/designers who use conventional CAD software. Following this, the toolbox with predefined shapes to be selected is eliminated, giving more space for general drawing in the Initial Shape window. The general display and functioning is similar to the previous mode so that the user can naturally evolve and use the next Expert Mode without having to interpret the functioning of the application again, according to SG-CONS (see Table 5). Also in the Intermediate Mode, according to SGRC-USEX-B (see Table 2) and SGRC-FLEX-C (see Table 3), a drop-down list exists in the Rules window for the use of Labels when creating the rules.
The Expert Mode allows availability of command lines to define Rules or change the SG through code. These command lines can be directly in the window of the task to be performed, or at the bottom of the entire interface, usable for any task. In this mode, the user is an expert in SG and/or in the development of the implementation itself, so expert tools are available, according to SG-USEX-D (see Table 2). The command lines will allow the Rule definition to be made with Rule Schemata or other input method needed/defined (Economou & Kotsopoulos, Reference Economou and Kotsopoulos2014).
As stated in section “IM-sgi application” above, this simple prototype is just an example. The prototype was defined for 2D SG, as this type of representation is adequate for the purpose of using SG in the architectural practice (Ligler & Economou, Reference Ligler and Economou2015). Further work involves prototypes that also consider 3D SG.
Conclusion
The present work aims to help computer SG applications effectively enter the design practice and become a relevant way of exploring ideas and project solutions. Designers and architects would be able to see SG as a real potential design technique and the computer as a partner. The architect has been changing the way of doing his job since he has had the chance to use the computer. Computational applications allowed reproduction of the architectural drawings, in addition to simulating 3D models. It became possible to explore multiple hypotheses, reduce project errors, and spend less time in searching for more complex solutions, achieving more ambitious, innovative, and creative projects. Applications based in SG can be tools that offer the designer the potential for Artificial Intelligence (AI) and CC.
We started with a brief introduction to SG and HCI. Then we presented how SG can lead to new ways of exploring project solutions and how we think this can happen with the correct interface for the computational SG implementations. Finally, describing the development of this investigation, IM-sgi is presented as our proposal of an interface model for SG implementations.
The beginning of the work in progress is presented here by an interface prototype for SG implementations, which allows an example of use of our established criteria for an interface definition. IM-sgi is defined by 259 criteria divided into 18 sections. In each section, there are six fields that organize the criteria between general and five directed for each task previously defined to work with SG. In order to validate the IM-sgi model, a prototype and its testing and evaluation are under development and will be presented in a subsequent paper. The objective is to show how IM-sgi criteria apply to different SG implementations, according to the different features they might possess (2D or 3D shapes, shape emergence, or other) and also to different types of interface and input, allowing newer techniques, such as eye tracking, to be used (Jowers et al., Reference Jowers, Prats, McKay and Garner2013).
Joana Tching (joana.tching@netcabo.pt) PhD Student in the Department of Sciences and Technologies of Information at ISCTE-IUL. Architect at FA-UTL, Lisbon. Experienced Architect in Building Information Modeling (BIM), Autodesk Revit Instructor. Her present research interests are Computational Design and Creativity, Artificial Intelligence, and Shape Grammars.
Joaquim António Marques dos Reis (joaquim.reis@iscte.pt) Assistant Professor in the Department of Sciences and Technologies of Information at ISCTE-IUL. Mechanical Engineer, MSc in Mechanical Engineering at Instituto Superior Técnico, Lisbon. PhD in Sciences and Technologies of Information at ISCTE-IUL (thesis “A Multi-Agent Scheduling Model in the Extended Enterprise”), Lisbon. Researcher and member of the Scientific Committee of ADETTI-IUL, an ISCTE-IUL investigation unit, and member of APPIA, the Portuguese Association for Artificial Intelligence. His present research interests fall in the areas of Artificial Intelligence, Computational Creativity, and Shape Grammars. Currently, he teaches the Artificial Intelligence and Technologies for Intelligent Systems course units (in the Telecommunications and Informatics Engineering course) and the Computational Creativity MSC course unit.
Alexandra Paio (alexandra.paio@iscte.pt) Assistant Professor in the Department of Architecture and Urbanism at ISCTE-IUL. Director and Researcher of VitruviusFabLab-IUL and Researcher at ADETTI-IUL. Co-Director of Advanced Studies Course in Digital Architecture (ISCTE-IUL + FAUP). PhD in Urban Design at ISCTE-IUL, entitled “urbanGENE: An Urban Grammar for Portuguese Settlements from the 16th to the 18th century”. Research at “OIKOnet. A global multidisciplinary network on housing research and learning” (co-financed by European Union). Her main research interests are Computational Design, Digital Tools and Processes to support the creative design, Interactive Architecture, Shape Grammars, and Digital Fabrication.
