Computer Science · 11th Grade

Active learning ideas

Software Design Principles: Separation of Concerns

Active learning works for Separation of Concerns because students need to see, touch, and rearrange tangled versus separated code to truly grasp why one structure is clearer than the other. When students physically separate responsibilities in their own projects, the cognitive shift from confusion to clarity becomes visible in real time.

• Common Core State Standards
• CSTA: 3B-AP-15
• CSTA: 3B-AP-17

• 25–40 min
• Pairs → Whole Class
• 4 activities

Activity 01

• Think-Pair-Share
• 30 min · Pairs

Think-Pair-Share: What Changed When You Mixed Concerns?

Give pairs two versions of the same program, one that mixes UI and data logic, one that separates them. Ask each student to add a new feature to their version, then compare how much code each had to touch. Discuss why the separated version required fewer changes in unexpected places.

Explain the principle of 'separation of concerns' in software development.

Facilitation Tip

During the Think-Pair-Share, provide a concrete before-and-after code snippet so students have a shared reference point for discussion.

What to look for

Present students with a short code snippet where concerns are mixed (e.g., UI logic directly manipulating database queries). Ask them to identify at least two distinct concerns that are tangled and explain why this mixing is problematic.

• Understand
• Apply
• Analyze
• Self-Awareness
• Relationship Skills

Activity 02

• Jigsaw
• 35 min · Small Groups

Jigsaw: MVC Roles and Responsibilities

Divide the class into three expert groups: Model, View, and Controller. Each group studies their layer's responsibilities and one concrete example. Groups then regroup in mixed triads to teach each other, then collaboratively label a provided architecture diagram with the correct layer for each component.

Analyze how separating concerns improves code readability and maintainability.

Facilitation Tip

For the Jigsaw activity, assign each group a specific MVC role and require them to prepare a two-minute script explaining their component’s responsibilities to the class.

What to look for

Facilitate a class discussion using the prompt: 'Imagine you are building a social media application. What are three major concerns you would want to separate, and why is it beneficial to keep them independent?'

• Understand
• Analyze
• Evaluate
• Relationship Skills
• Self-Management

Activity 03

• Project-Based Learning
• 25 min · Individual

Annotation Sprint: Finding Concerns in Existing Code

Provide a short program (40-60 lines) that mixes data access, calculation, and display logic throughout. Students annotate each block with a colored marker (or comment) indicating which concern it belongs to. As a class, identify which blocks should be moved and sketch a refactored structure.

Design a simple application structure that demonstrates separation of concerns.

Facilitation Tip

When running the Annotation Sprint, project a sample file and model how to mark each block of code with sticky notes labeled by concern type before students work on their own.

What to look for

Ask students to write down one example of a software component or file they might create to represent a single concern in a simple 'to-do list' application, and briefly describe the responsibility of that component.

• Apply
• Analyze
• Evaluate
• Create
• Self-Management
• Relationship Skills
• Decision-Making

Activity 04

• Project-Based Learning
• 40 min · Pairs

Design Critique: Architecture Review

Student pairs design a simple to-do app architecture (on paper or a whiteboard) and then swap with another pair for critique. Reviewers identify any points where concerns appear to be mixed and suggest how to separate them. Both pairs present their original and revised designs.

Explain the principle of 'separation of concerns' in software development.

What to look for

Present students with a short code snippet where concerns are mixed (e.g., UI logic directly manipulating database queries). Ask them to identify at least two distinct concerns that are tangled and explain why this mixing is problematic.

• Apply
• Analyze
• Evaluate
• Create
• Self-Management
• Relationship Skills
• Decision-Making

A few notes on teaching this unit

Teach Separation of Concerns by starting concrete and moving to abstract. Use side-by-side examples of tangled versus separated code so students notice the difference in complexity firsthand. Avoid abstract lectures until students have wrestled with real code samples. Research shows that novices grasp architectural principles better when they first experience the pain of tangled code before seeing the benefits of separation.

Successful learning looks like students confidently identifying mixed concerns in code, proposing clean boundaries between components, and justifying those boundaries with concrete reasons. They should be able to explain how separation makes future changes easier without adding unnecessary complexity.

---

Watch Out for These Misconceptions

• During Think-Pair-Share, watch for students who assume Separation of Concerns means putting each function in its own file.

  Use the provided mixed-concern snippet to highlight how multiple functions can belong to the same concern even if they’re in one file, and how a single function might handle two concerns if it mixes data access with UI logic.

• During Jigsaw: MVC Roles and Responsibilities, watch for students who believe Separation of Concerns only applies to large applications.

  Have each group present how even a small feature like a user profile page benefits from keeping data management, logic, and display separate, making changes predictable and isolated.

• During Annotation Sprint: Finding Concerns in Existing Code, watch for students who think Separation of Concerns always makes code longer or more complex.

  Ask students to compare the original tangled code with their annotated version, then count lines added versus lines removed to show how separation actually reduces complexity over time.

---

Methods used in this brief

• Think-Pair-Share
• Jigsaw
• Project-Based Learning