Introduction to Parallelism: Doing Multiple Things at Once

Active learning works for this topic because parallelism is a concrete, observable concept. Students need to see and manipulate code that behaves differently from what they are used to in sequential programming. By engaging in hands-on activities, they directly experience how parallelism changes program behavior, making abstract ideas like concurrency and race conditions tangible.

• JC 2
• Computing
• 4 activities
• 25 min–45 min

Learning Objectives

1. Compare the execution flow of sequential versus parallel programs using pseudocode.
2. Design a simple animation demonstrating independent movement of at least two program entities.
3. Explain how concurrency contributes to program dynamism and responsiveness.
4. Identify potential synchronization issues in a parallel execution scenario.

⏱ 30 min·Pairs

Pair Programming: Independent Sprite Paths

Pairs code two sprites to follow unique paths across the screen: one sequentially, then both in parallel. They time completion and note differences in responsiveness. Pairs share screenshots of before-and-after animations with the class.

Prepare & details

What does it mean for a computer to do things 'in parallel'?

Facilitation Tip: During Pair Programming, ask each pair to measure the time it takes to complete the sprite movement task sequentially and in parallel, then compare results to challenge the speed assumption.

⏱ 45 min·Small Groups

Small Groups: Parallel Game Challenge

Groups build a simple game where three elements (e.g., balls, enemies) move concurrently while avoiding collisions. Start with block-based code, add parallelism, and test for smooth interaction. Groups present winning designs.

Prepare & details

How can making things happen at the same time make a program more dynamic?

Facilitation Tip: In the Parallel Game Challenge, circulate to ensure groups test their code with increasing numbers of threads to observe how performance changes with load.

⏱ 25 min·Whole Class

Whole Class: Concurrency Demo and Debug

Project a shared program on the board. Class suggests parallel additions, codes live, and votes on fixes for issues like overlapping paths. Everyone predicts outcomes before running.

Prepare & details

Design a simple animation where two characters move independently.

Facilitation Tip: For the Concurrency Demo and Debug, deliberately introduce a race condition in the shared score example so students can see the error and discuss fixes in real time.

⏱ 35 min·Individual

Individual: Personal Parallel Animation

Each student designs an animation with at least four independent movers, like a bustling city scene. They document challenges and solutions in a short reflection log.

Prepare & details

What does it mean for a computer to do things 'in parallel'?

Teaching This Topic

Teach this topic by starting with observable behavior before diving into theory. Use analogies like students working in a kitchen: some tasks can happen at the same time, but others require coordination. Avoid overwhelming students with low-level threading details early; focus on high-level concepts like independence and synchronization first. Research suggests that students grasp parallelism better when they can visualize and manipulate it, so prioritize activities that make concurrency visible.

What to Expect

Successful learning looks like students describing parallelism in terms of simultaneous actions rather than speed. They should confidently explain how independent tasks can run without blocking each other and identify when synchronization is needed. You'll see this in their ability to debug race conditions and justify design choices in their animations.

Watch Out for These Misconceptions

Common Misconception

During Pair Programming, watch for students assuming parallel code always runs faster than sequential code.

What to Teach Instead

Have pairs time both versions of their sprite movement task and compare results. Ask them to explain why parallel code might not always be faster, focusing on overhead like context switching.

Common Misconception

During Parallel Game Challenge, watch for students believing computers can run unlimited parallel tasks without limits.

What to Teach Instead

Provide each group with a table to record how long it takes to complete tasks as they increase the number of threads from two to ten, so they observe bottlenecks when threads exceed CPU cores.

Common Misconception

During Concurrency Demo and Debug, watch for students assuming independent parts in parallel code never interfere with each other.

What to Teach Instead

Deliberately include a shared score variable in the demo code and let students debug the race condition that occurs when two threads try to update it simultaneously.

Assessment Ideas

Exit Ticket

After Pair Programming, provide students with two short code snippets: one sequential, one parallel, both moving two sprites across the screen. Ask them to write one sentence describing the difference in execution flow and one potential advantage of the parallel approach.

Quick Check

During Parallel Game Challenge, display a scenario on the board: 'Two students are updating a shared score in a game. Student A adds points, Student B subtracts points.' Ask students to identify if this is a sequential or parallel task and what problem might arise if they don't coordinate their actions.

Discussion Prompt

After the Concurrency Demo and Debug, facilitate a class discussion using the prompt: 'Imagine you are designing a traffic light system for a busy intersection. How could you use parallelism to make the system more efficient, and what are the risks if the signals are not synchronized correctly?'

Extensions & Scaffolding

• Challenge students to add a third sprite to their Personal Parallel Animation and explain in comments how they ensured all sprites moved independently without collisions.
• For students who struggle, provide a scaffolded starter file with pre-labeled sections for sprite initialization, movement logic, and synchronization, and ask them to complete only one section at a time.
• Deeper exploration: Ask students to research how operating systems handle thread scheduling and present a short explanation of why context switching has overhead.

Key Vocabulary

Parallelism	The ability of a computer system to execute multiple tasks or computations simultaneously, rather than one after another.
Concurrency	A property of systems where multiple computations can be in progress at the same time. These computations may or may not be actually executing at the same instant.
Thread	A single sequence of execution within a program. Multiple threads can run concurrently within the same program.
Synchronization	The coordination of concurrent threads or processes to ensure they access shared resources in a controlled manner, preventing conflicts.