Background
In 2020, the Computational Design department was founded at Ryan Companies.
Computational design has a lot of different definitions, but for the purpose of this case study, it’s simply R&D for creation of architectural 3D geometry.
I was hired in early 2021 to provide support to get this new team off the ground.
The project described in this case study has been simplified, and its story told in non-linear time. I have also re-imagined some of the interaction and UI design presented in this case study.
Computational Design - an R&D Department
The primary objective of the department was to identify slow and/or painful points in the existing workflows within the architectural design process and research market solutions to improve these processes. Where market solutions wouldn’t suffice, the team was tasked with building the solution in-house.
Ryan Companies offers national, comprehensive real-estate services, everything from a team of developers to architecture and engineering (A&E), all the way to building managers. It staffs over 1500 people, and is active in 9 major industries.
MY Role
In 2021, I was brought onto the team. Over the next 2 and a half years, I would be responsible for the interaction design and UI design of new applications, as well as developing interfaces on the Windows Presentation Foundation, built on C# and XAML.
I worked alongside 2 managers, a font-end web developer, and another associate, totaling 5 people by 2022.
My involvement ended unexpectedly in mid 2023 due to unexpected layoffs in mid-2023.
IDentifying pain points
When the team was founded, nobody knew concretely where the inefficiencies or pain points were in Ryan's processes. The team had to do some serious investigation to understand where problems might be. Unfortunately this process was made more difficult due to the sudden onset of COVID-19 in 2020, as all investigation quickly turned from in-person observation to remote meetings revealing only anecdotes.
Map of Ryan Companies Offices
Investigating annecdotes
"It would be nice if I..."
- Architects (and everyone else, everywhere).
The team started by investing the context around anecdotes from leaders within the different sectors in Architecture & Engineering (A&E). We were trying to answer the following questions:
- What is the scope of this inefficiency?
- Are there market solutions that solve this problem?
- If there aren't, what is the lift to build it?
Early on, we investigated a few primary areas, and in most cases we found market solutions insufficient, created prototype tools to try and solve some of these problems.
Industrial building generation
Many types of industrial buildings have strict rules that define their creation. I explored creating a tool to generate them from drawing a boundary.
Parking Lot Generation
Parking lots, another prescriptive element, were tedious to draw, and if the design of a structure changed at all, often these had to be entirely re-drawn.
BOMA Calculations
BOMA calculations are used to determine a building's rentable area. Cullen Sarles explored creating a tool to reduce this very tedious and repetitive work.
Rhino 3D To revit importer
Designers would lose work moving from a lower fidelity prototyping tool like Rhino to a much higher fidelity tool like Revit.
A Startling Discovery
In early 2022, a member of the A&E team for multi-family projects came to us with a problem in early-stage modeling, hoping we could provide a solution.
The multifamily team was using an excel sheet to calculate the feasibility of a site to give the development team a go or no-go. There were often hundreds of data points to be entered by hand, for each iteration of the massing model, for each site pursuit. This process took weeks, and any time wasted here prevented Ryan from getting an early bid in to new sites.
Of course, if it turns out the site was not feasible (a no-go), all that time and work is wasted.
"Hundreds of data points were being entered by hand, for each iteration of a massing model, for each site pursuit."
How might we create a bridge between what was happening in the 3d environment, and the excel sheet the team was working with, so they could see the feasibility of the massing model in real-time, and make quick adjustments on the fly?
Further Investigation Revealed An Opportunity For a platform to create jumpstart tools
Poking around other adjacent sectors, notably senior living, revealed similar early-stage design inefficiencies there as well.
We also connected the dots between the early-stage modeling needs for residential and industrial, and efforts kicked into full gear on developing a platform to solve all of these problems. Many of these inefficiencies were addressed by solving a root problem, a shortcoming of many popular early stage architectural modeling tools, assigning data to objects.
An object becomes an area representing studio apartments.
This curve representing a site boundary becomes a real site boundary object that now calculates the area and stores the data.
.png)
Simple software architecture = simple interaction design
When building an application with this many moving parts, the architecture and interaction design of the system go hand and hand. The simpler the architecture of the system, the fewer systems the user has to interact with at accomplish a given goal.
No products (that we found) currently exist in the marketplace that solved the problems we needed. However, a framework emerged at the end of the 20th century that could be adapted to solve our problem.
This was the dynamic trio of HTML, CSS, and JavaScript.
Lessons from web development
Web development is split up into 3 main components, each with a standard language and subsequent structure.
- HTML - The hierarchical structure of a system.
- CSS - The way the system looks.
- Java Script - What the system does.
Though not a perfect analogy, the interaction between these three components is a direct mirror to the ideal interaction between Rhino 3D (HTML), Grasshopper (JavaScript), and an application the computational design team had been building since 2020 called Chimera (CSS).
All we had to do is bridge the gap between perfection, and the current state of the various components of the system.
Working backwards from perfect
With a robust, pre-existing framework to follow, 3 pillars of this design challenge solidified to reduce the cognitive complexity of the system down to something manageable.
Rhino 3D: from amourphous to structured
The default organization style in Rhino3D (and many modeling programs) is by using layers, or "groups". But, what happens when you need one or more groups as children of a parent group? What happens when you have multiple ancestors of the parent group?
Creating hierarchical structures in Rhino 3D was a challenge that needed to be addressed, and we could do by reimagining a clunky but built-in feature called blocks. For those that have used components in Figma, blocks function similarly are equivalent to frames.
Designers would still be free to use layers to add additional organization to files if they would like.
The Information architecture of architecture
Buildings inherently are hierarchical, as certain objects literally combine to create other objects. At the level of massing models, this hierarchy is much simpler than at the level of a building information model (BIM). Because this hierarchy is not too complex, we can realistically map it out.
.png)
We can then create and aggregate these maps across all of Ryan's standard project types to determine the common elements in the maps, and create a baseline that can then be extended to support a theoretically infinite number of project types.
.png)
This pattern is extremely common - creating a platform that can be extended to fit individual needs. Imagine a house, you need a kitchen, bathroom, and bedroom. Most probably want a living room, some people a sun room, and others perhaps a theater room. In this analogy, these rooms are the extensions of the core template, and an infinite number of them can be created.
Before
Exiting Rhino 3D layer management system. Supports one to many relationships, and rudimentary hierarchical relationship.
After
Moving away from the layer panel. The object navigator supports components, and aims to define a hierarchy in the modeling environment, and gives designers heightened visibility into the system status.
Chimera - From ambiguous to Explicit
Chimera was a meta-data assignment tool that saw development begin in 2020, years before this point. The team knew its functionality would be needed, but did not have a particular problem to point the software at.
Rhino, like most modeling software, lacks the proper tools to assign information to objects within an environment. This is a particularly big problem if someone were to query the environment for boundaries representing floors. Without assigning the object some data in an expected, easily replicable format, it would be impossible to know if a boundary represented a site, floor, pond, parking lot, or something else.
Chimera solved the problem by allowing for the creation of tree-like data structures that are assigned to objects, similar to how a CSS style might be assigned to a div.
Creating re-usable pieces of our data structure
We can build an editor for Chimera by mimicking how we might go about manually constructing a tree structure. We:
1. Create attributes by first building the leaf nodes that contain the data.
2. Create species to build out parent nodes to connect attributes (leaf nodes) and help categorize that data.
3. Create prototypes (collections of objects with species attached to them) that pair data with objects, and quickly define entire branches of the tree that can be used in the modeling environment.
Creating an editor required creating a ryan style guide
Ryan, up until this point, had not needed a style guide for how interfaces looked. This project, and another few that were in also development required one to be built out. I worked with Ryan's branding team to turn their branding guidelines into a style guide.
Eventually, there were plans to create a component library for multiple platforms, including:
Even just developing tools for the jumpstart tool suite required component libraries for Human UI and WPF.
I elected to adapt Ryan's brand to Material Design for simplicity sake, though a huge amount of design and development work was still needed. A design system made from materials for a company that builds with materials. Poetic.
The vision for this library also included a good amount of information and instruction on how to use it, and how to build interfaces. With all of the initiatives in the insights and innovations department, Ryan needed more interface and UX designers. I aimed to provide as much informative and educational material to resident analysts and developers in the buisness to help address this need.
A tool by computational desigenrs, for computational designers
Putting all of this functionality together to create building blocks for the end user results in a simple but very powerful interface separated into three stages. Attribute building, species building, and prototype creation.
Create leaf nodes.
Create parent nodes.
Create sub-trees.
grasshopper - From complex to simple
Having taught grasshopper to third year university students, I have experienced first-hand how challenging learning visual programming tools can be. To really excel with these tools, some computer science knowledge is required, which is not something architects are trained in.
This fear of the unknown extended from creation of grasshopper scripts to encompass even utilizing them. Loading up a document and adjusting some parameters was too much of a barrier to deploy applications using the built-in tools of Rhino and Grasshopper 3D.
Anatomy of a grasshopper script ⚡
Inputs
There are two types of inputs in a Grasshopper script, geometric (objects in the modeling environment), and simple data types like numbers, strings, booleans, etc.
We can reference data by tying those inputs to data types declared by Chimera.
and...
we can reference geometry by assigning the Grasshopper script to a block and querying its geometric children to match inputs to objects with the correct Chimera species assigned to them.
Logic
This is the meat of the script, and other than building some custom grasshopper components to retrieve chimera data from the Chimera data-base, no additional work is required here.
Outputs
This is where we see the result of the script. We can create objects within the rhino environment and assign chimera data to them if we need, or just write and update existing chimera data on objects.
Grasshopper becomes "smart" functionality
To ease the fear of the unknown surrounding grasshopper, we can add a think yet informative layer between the user and the software - an interface that simply presents the inputs and outputs using a familiar language. This way, users won't even know they are interfacing with grasshopper at all unless they care to peek under the hood of the application.
We can use the term "smart" functionality to indicate that there are calculations being done on the object under the hood of the application without the user being aware of how. All the designer needs to know is which objects are/have some number of inputs and outputs.
.png)
Bringing it all together
After nearly 2 years of on-and off work on Chimera, accompanied by rigorous experimentation and exploration of the interaction design, we finally had a working proof of concept.
Unfortunately, in June of 2023, layoffs hit the Insights and Innovations department, and while some of the work I did on this project (from my understanding) has continued to evolve and be a core part of the applications functionality, the future of this project is unknown and uncertain.
A significant amount of thought has gone into writing this case study to tie up loose ends that were still question marks when a significant portion of the parent department, and 2 of the 5 members of the computational design team were cut.
We were planning, upon completion of this development platform, to finish building MYST, and branch out to build other applications and other smaller but very helpful tools, like advanced parking generation, site importers, solar studies, and more.
Released and Unrealized Impact
The creation of the jumpstart ecosystem and the material around it - notably the component library did show some overwhelming promise. We saw...
A 50-80% decrease in early-stage modeling time for multifamily and senior living projects.
A reduction of weeks of design time to days or hours of design time (estimate based on most recent anecdotal data).
A 297% INCREASE in dashboard usability scores
Due to creation of a style-guide preceding the component library for the data-team specifically. This was measured by comparing before and after heuristic analyses, with scores (out of 10) going from an average range of 2-4, to an average range of 7-9.
