Part of the MFA Interaction Design Weekly Thesis Blog series - 12 of 64

I happen to think it is a good idea for designers to learn to code. Not because it will make them unicorns (great as that may be), but because code offers some unique possibilities as a design medium, and because computational thinking makes better problem solvers (and thus better designers).

Designing in code is not fundamentally different than design in other mediums. It is still the pursuit of useful beauty, it still requires empathy with your audience, it still uses the cyclical process of definition, iteration, and observation.  So, what is unique about code as a medium for design? I want to propose a couple ideas.  Let’s start with some unique strengths of code as a medium.

Interactivity and Computational Power

Interactivity: Through code we are able to create deep, complex interactions which are difficult to achieve in other mediums. With code, we control computers and through them our designs can react immediately to audience input. We can even engage in complex back-and-forth interaction with our audience.

Computational Power: Code allows us to deal with complexity through raw computational power. With bits of code we can crunch through millions of datapoints and investigate its meanings. We can discover and extract complex relationships within data, express them in new forms and communicate with a high level of precision.

To leverage interactivity and computational power in design, designers don’t necessarily have to be proficient at programming. Knowing all the nuances of syntax and programming language gotcha’s will not make you a better designer.  What designers do need is computational thinking, or how to formulate and frame problems so they are solvable by computers.  

Computational Thinking and Algorithms

What do we mean by ‘solvable by computers’? Computers are logic machines, which can accurately and repeatedly perform complex instructions, as long as they are specific, explicit and well defined. Computational thinking is about carefully framing problems and decomposing them into simple, concrete parts, so that a specific, step-by-step solution can be applied.

A specific and well defined set of instructions is call an algorithm.  While the term may not be familiar, algorithms are actually around us all the time.  When you are giving a stranger to the city directions, you’re giving them an algorithm to follow. When you are following a recipe in a cookbook, you are executing an algorithm.  Creating algorithms for computers is essentially what programmers do all day.

You Already Do This

You already think algorithmically, just not to the same level of rigor and explicitness that programmers do. Michelle Levesque of rwxweb wrote a wonderful blogpost about recognizing algorithmic thinking, through exercises she calls thinking big and thinking small:

“How do I make a sandwich?”

“You take two pieces of bread and […]“

“Where do I get the bread?”

“Your fridge.”

“How do I get it from the fridge?”

“You open the door and get it.”

“Okay, so I open the door.  Now how do I know where the bread is?”

“You look around and find it.”

“Okay, so I look around and the first object is mustard.”

“Keep looking.”

“Okay, so we have our first two steps now.  First, we open the fridge.  Second, we examine each object.  If it’s the bread, we take it out.  If not, we look at the next object.  And we keep repeating until we find the bread.  What next?”

By asking her student to be very explicit and specific, she’s asking them to think small and sweat the details of coming up with precise algorithms. Thinking small forces us to recognize how much nuance is embedded in what we consider simple tasks.

What about thinking big?

“How many chickens does San Francisco eat every year?”

Stunned silence.

“Well, is the answer 1?  1 chicken?”

“No.”

“Is the answer one hundred thousand million billion?”

“No.”

“So you have some idea of where it should fall.  Some guesses are better than others.  Let’s see.  How often did you eat chicken last week?”

“3 times?”

“Okay, so if that was an average week, you eat chicken 3 times a week.  Was it a whole chicken?”

“Wait, I’m a vegetarian.”

“Okay, so what percentage of the people in San Francisco do we think are vegetarian?”

“A third?”

“Okay, so what if we say that a third of the people eat chicken never, and the rest eat it about 3 times per week.  Does that sound about right?  How many people live in the city?”

etc.

Notice how they looked at a baffling problem and began to find the seams in it. Repeatedly, step by step, they cut the problem down into its component parts, each of which are smaller and potentially easier to solve.

Computational Thinking for Designers

Designing with code is leveraging computational thinking to achieve design goals. The benefits of computational thinking is not tied to any particular programming language, or even to the domain of computers. Once you understand how to make algorithms work for you, new design possibilities open up and new solutions to complex problems become available.