Code Roads is a modular children's toy that helps kids learn the fundamentals of coding logic. With this building platform, kids can create their own Rube Goldberg like systems using components that are built to behave exactly like specific coding concepts. By making these abstract concepts tangible, kids gain a concrete roadmap of how code behaves.

This project was initially inspired by a common children's toy – a marble ball track. As I watched kids play with this early toy, I realized that it functioned very similarly to my basic mental model of how code flows together. It has a distinct structure, triggers and signals, and could be re-programmed by building different layout.

The final system works similarly, kids have four types of components they can use to build their own roads. Each piece is magnetic and can be re-positioned onto metallic surfaces (such as a refrigerator). Once kids build a road, they can watch how its structure and the various intelligent modules funnel marbles around.

Starting things off are Inputs, that react to real world stimuli(such as sounds or motion), which when activated drop marbles (signals) into the system. Kids can then build out different roads and intersections that change the pathways and flow of the marbles. Some intersections are smart such as "AND", which only lets marbles through if it receives two marbles, one from each of its arms. Kids can easily tell if the intersection has received the right conditions, by looking at the feed back lights in each arm (green for condition met and red for condition unmet). The final components are outputs, such as rotary motors or beepers, these are the final effect and activate when a marble passes through.

This toolkit of components creates an endless set of possibilities for kids to experiment with. In my research, I worked with kids to see what smart machines/programs they would create. They came back with machines that would open their door whenever their dog wanted to get outside, conveyor belts that turned on a coffee machine for their parents, and an alarm system that would protect their toy box from their little brother. All of these machines were built using just basic logic concepts, and each program helped kids help themselves.

Many new children's coding initiatives and curriculum treat code as separate activity – one that can only be learned on the computer. Code Roads instead combines tangible interaction principles to help make the introductory stages of learning code as approachable, intuitive, and fun as possible.

What if a computer wasn't necessarily the best place to learn the fundamentals of coding? My master's thesis for Interaction Design at Umeå Institute of Design is an exploration as to how we can make learning basic coding as intuitive as building with blocks.

Problem:

In the last few years America as a whole has taken an interest in bringing coding to school education. New initiatives are popping up in order to get younger students involved, but many still have similar challenges that traditional coding education faces. The initial learning curve is high, a whole new vocabulary has to be learned, and the ever present possibility of failure scares many kids off coding forever. The goal of Code Roads is to create a much more approachable and explorative introduction to the world of coding.

Initial Interest:

My choice in this topic was in part inspired by my own challenges learning to code. I've slowly discovered that I learn best through concrete examples and highly visual processes. Abstract concepts never really stuck, or if they did it was only because I translated them into a comparable physical metaphor. Loops were pictured as roller coasters on tracks, exponents represented as the speed of the cart – I truly needed these representations.

Research:

As part of research I shadowed elementary coding classes, interviewed both current students and teachers, and tried to isolate many of the challenges present in learning this new skill. I chronicled as kids explored modern platforms such as Code.org, and also early straight text input, making the computer say "hello world".

Development

Over the course of two months I built and developed prototypes to test with kids. Early mock ups were little more than magnetic foam core pathways built to look like an "AND" and "OR". Later models featured testing ready sensors that reacted to marbles and triggered outputs in real time using IR Beams.

Final Result:

Code Roads is a children's toy which translates the early fundamental logic required to learn coding into physical blocks. By translating highly abstract concepts into tangible components, kids are given a mental road map of how code functions from an early age. This direct tethering of abstract concepts to toys gives kids a more concrete connection and utilizes the predictability found in the physical world to make sense of a complex new ways of thinking.

Code Roads is composed of a series of re-positionable magnetic tracks that funnel marbles through them. The various structures of the tracks mimic the behaviors of different programming logic, and can be used to help visualize complex systems. Kids can then re-arrange the system in order to "program" its response in order to solve their own problems. The whole system lives on the refrigerator in kids homes and is meant to be integrated into their daily lives instead of living exclusively within a computer.

What differentiates this projects from many other coding exercises is that it makes physical not only the "commands" but also the signals. In this way every piece of the system is clearly visible to kids, whereas a digital system would not be.

While making such a highly visible and complex system may seem overly complicated to adults, children of this age revel in understanding each bit of complexity from start to finish, and proving their own mastery serves as a sense of pride.

Early Goals:

Predict the journey through the code, not just the input and the end result

Code Roads relies on gravity to propel signal marbles through the system. Since it is fairly easy to understand gravity, kids are given a clear road map of how their built system will behave even before they run it. Additionally by conducting a simple visual walk through of each chunk of "code", they can preemptively understand how the system will flow. This stands as an improvement over other graphical or text based systems where there is a larger "moment of truth" between first running the code and waiting to see if it will function as intended. This predictability makes it easier for kids to visualize exactly where the code began, what state it is in at all times, and finally; reliably be able to predict where it is going.

One concept one object

This system has individual modules that stand as a physical representation of abstract coding concepts. By creating a single object, it gives form to the abstract concept and allows kids to mentally associate/tether the object to that concept. In this way, even when kids are not engaging directly with the system, but mentally envisioning it, they get a concrete point of reference to work off of.

Encourage collaboration not isolated learning

The modular nature of the system encourages collaboration between multiple users. Chunks of "code" can be easily shared between kids by picking them up and moving them, and in this way "code" can be created and improved simultaneously.

Help kids solve their own problems, not just examples

By making this toy essentially a hacking toolkit with emphasis on automation, it pushes kids towards finding applications in their own life. Whereas in traditional coding education there is typically a huge leap between learning concepts and being able to create something useful or rewarding with them, Code Roads encourages immediate implementations.