Jamie Liao

As part of my M.Ed., Educational Psychology from Rutgers University, I took a class on problem-based learning (PBL). PBL supports the school of thought that students lead their learning through natural inquiry in an open-ended problem and instructors are support systems (aka scaffolding) to nudge students in the right direction.

I designed a PBL exercise that teaches computational thinking through an unplugged, non-programming approach. Although this blog targets first-year women at the university level, these exercises could be tailored to different age groups.

This blog serves as a summary of the full term paper I wrote; you can find the full paper here.

What is Computational Thinking?

Wing (2006) defined the modern term for computational thinking (CT) as “the thought processes involved in formulating problems and their solutions so that the solutions are represented in a form that can be efficiently carried out by an information-processing agent” (Wing, 2010, p. 1). 

CT stems from CS; it breaks down the core concepts from programming (decomposition, pattern recognition / data representation, generalization/abstraction, and algorithms) into a general problem solving method.

However, while CT encapsulates more than just the field of CS, most educational approaches to CT still revolve around coding exercises and programming concepts. This is especially prevalent in K-12 education. But computer science isn’t just about programming.

When most people think “computer science education,” they picture students hunched over screens, typing lines of code. This creates two major issues:

1. Misconception about CS: Students and teachers, especially those in K-12, think CS is just programming. This misconception misses the broader problem-solving aspects, which I fell in love with.
2. Accessibility barriers: Not everyone learns best through programming-first approaches or has access to programming courses. It’s common for K-12 CS teachers to have mathematical backgrounds, not CS.

So, what if we teach students the core concepts of CT while exploring the expansive field of CS without ever touching a keyboard? The goal of this activity is to not only teach CT concepts, but also excite the students about new CS concepts/fields without reinforcing the “CS == coding” misconception.

The Problem: Bus Route Recognition

Instead of teaching algorithms through code, I created a real-world problem that students could relate to immediately: How does a computer program recognize a Rutgers bus from a photo and display its route information?

This problem might seem simple at first glance, but there are a lot of moving technical components that beginners may not recognize. breaking it down reveals core computational thinking concepts. I focused on two fundamental CT pillars from Shute et al.’s (2017) model: decomposition (breaking complex problems into manageable parts) and abstraction (extracting key information while hiding irrelevant details).

The bus recognition problem naturally requires both:

• Decomposition: How do we break “photo → bus route” into precise instructions that a computer (or even another human) could replicate?
• Abstraction: What information matters in a bus photo? How do we organize route data? And more broadly, how can we construct a system while acknowledging the “black box“?

The Learning Experience: 4 Key Areas

Working small groups (ideally groups of 3), students explore four (4) interconnected areas. These areas are not expected to be done in any order, but rather explored based on the students’ interest.

1. Exploration Phase

Students start with guided questions to support their initial discovery and decompose the overall problem:

• What are the core components of this challenge?
• What do we know about the input and the type of data we can get from it?
• What are the various types of data or information we need? How can we organize and use it?
• What are some unique aspects of each letter we can use to uniquely identify them?
• What are some visual ways to represent a set of rules?

2. Image Analysis (Pixels & Data)

Using colored paper squares, students recreate pixelated letters like “A” and “H” to understand:

• How images (pixels) become parsable data
• What information matters for letter recognition patterns
• How computers “see” pictures

💡 Hands-on Learning: Models (e.g. physical paper “pixels”) makes abstract concepts tangible and supports student learning by connecting implicit information.

3. Database Creation

Students build simple Excel-like table to model a simple SQL database to:

• Organize and structure information in a format that supports repetition
• Practice data storage concepts
• Understand input → output relationships

4. Decision Tree Building

To bring together the past 3 areas of interest, students create a decision tree/flowchart to identify bus letters based on visual features. Some example questions in the decision tree are:

• Does the letter have horizontal lines?
• Are there diagonal components?
• How do we distinguish “A” from “H”?

The Bigger Picture: Redefining CS Education

By the end of the activity, students have created a complete system design that mimics AI pattern recognition—all without writing a single line of code. They’ve essentially built the very basic logic for a bus recognition app using paper, markers, and critical thinking.

This approach tackles several misconceptions about computer science, especially for women in CS:

1. CS ≠ Just Programming: Students experience problem-solving, system design, and logical thinking beyond simply programming. Beginner programmers are so tunneled on their syntax. They may not recognize the problems they are solving, which is at the core of CT and CS.
2. Interdisciplinary Connections: The exercise connects CS to many different fields, such as cognitive science and visual perception. This expands the student’s understanding that CS concepts exists in every field and is applicable to any field.
3. Practical Relevance: Solving a real, relevant problem (navigating bus routes) because these students are incoming first years and they’re trying to navigate the complicated campus bus system.
4. Personal Projects: Students get a real example of a possible “personal project,” an abstract concept I struggled to understand when I first started in CS.

The Results: Computational Thinking in Action

Students demonstrate mastery of key CT concepts that are achieved through collaborative problem-solving rather than individual programming:

• Decomposition: Breaking the bus recognition problem into manageable components
• Abstraction: Identifying essential features for letter recognition
• Pattern Recognition: Creating rules to distinguish between different bus letters
• Modeling: Building decision trees to represent AI logic

Conclusion:

Computational thinking isn’t about knowing syntax or debugging code—it’s about approaching complex problems systematically, breaking them into manageable parts, and designing elegant solutions.

By teaching these thinking skills through relevant, hands-on challenges, we can make computer science more accessible and help students understand that at its core, CS is about creative problem-solving. The bus route recognition exercise proves that students can learn computational thinking without a computer.

This blog serves as a summary of the full term paper I wrote; you can find the full paper here.

References:

• Shute, V. J., Sun, C., & Asbell-Clarke, J. (2017). Demystifying computational thinking. Educational Research Review, 22, 142–158.
• Wing, J. (2006). Computational thinking. Communications of the ACM, 49(3), 33-35.

---

My goal is to break down technical concepts through the lens of educational psychology. If you’ve found my explanation or breakdown helpful, please let me know in the comments!

If you’d like to hear more about a specific topic, comment any topics below too.