Introduction to Design Patterns

Active learning works especially well for design patterns because students need to see, touch, and debate code to truly grasp how abstract solutions solve concrete problems. When students write, modify, and critique patterns in real time, they move from passive reading to active understanding, which strengthens their ability to recognize when and how to apply these tools.

• Grade 11
• Computer Science
• 4 activities
• 25 min–45 min

Learning Objectives

1. Explain how the Singleton pattern ensures a single instance of a class is created and accessible globally.
2. Analyze a given code snippet to identify which design pattern, if any, is being implemented.
3. Compare and contrast the Factory Method and Abstract Factory patterns in terms of their object creation strategies.
4. Critique the suitability of applying the Decorator pattern to a simple class structure, considering its impact on code complexity.
5. Design a basic implementation of the Observer pattern to manage updates between a subject and its observers.

Case Study Analysis

⏱ 30 min·Pairs

Pair Programming: Singleton Implementation

Pairs start with a basic class that creates multiple instances. They refactor it to enforce a single instance using the Singleton pattern, test with multiple calls, and log instance counts. Pairs then share one success and one challenge with the class.

Prepare & details

Explain how design patterns promote code reusability and maintainability.

Facilitation Tip: During Pair Programming: Singleton Implementation, circulate and ask each pair to explain how their private constructor prevents multiple instances, listening for precise language about class-level control.

Setup: Groups at tables with case materials

Materials: Case study packet (3-5 pages), Analysis framework worksheet, Presentation template

• Analyze
• Evaluate
• Create
• Decision-Making
• Self-Management

Case Study Analysis

⏱ 45 min·Small Groups

Small Groups: Factory Pattern Challenge

Groups receive code needing flexible object creation, like shapes. They implement a Factory method to create objects based on input strings. Groups test variations and compare their solutions, noting reusability gains.

Prepare & details

Analyze a specific design pattern (e.g., Singleton) and identify its use cases.

Facilitation Tip: For the Small Groups: Factory Pattern Challenge, provide scaffolded starter code with commented-out sections so groups focus on the pattern’s core logic rather than syntax errors.

Setup: Groups at tables with case materials

Materials: Case study packet (3-5 pages), Analysis framework worksheet, Presentation template

• Analyze
• Evaluate
• Create
• Decision-Making
• Self-Management

Case Study Analysis

⏱ 35 min·Whole Class

Whole Class: Pattern Critique Debate

Present simple code snippets, some with patterns and some without. Class votes on improvements, then debates pros and cons in two teams. Facilitate with guiding questions on maintainability and overkill.

Prepare & details

Critique the potential over-application of design patterns in simple software projects.

Facilitation Tip: In the Whole Class: Pattern Critique Debate, assign roles (advocate, critic, neutral observer) to ensure every student participates and hears multiple perspectives.

Setup: Groups at tables with case materials

Materials: Case study packet (3-5 pages), Analysis framework worksheet, Presentation template

• Analyze
• Evaluate
• Create
• Decision-Making
• Self-Management

Case Study Analysis

⏱ 25 min·Individual

Individual: Pattern Hunt in Code

Students examine provided open-source snippets or their past projects. They identify one design pattern, document its problem solved, and suggest an alternative without it. Share findings in a class gallery walk.

Prepare & details

Explain how design patterns promote code reusability and maintainability.

Facilitation Tip: During Individual: Pattern Hunt in Code, give students a checklist with pattern names and symptoms to look for, such as static methods or inheritance hierarchies.

Setup: Groups at tables with case materials

Materials: Case study packet (3-5 pages), Analysis framework worksheet, Presentation template

• Analyze
• Evaluate
• Create
• Decision-Making
• Self-Management

Teaching This Topic

Teach design patterns by treating them as tools students already use intuitively, then formalize their understanding through structured activities. Avoid presenting patterns as rigid templates; instead, emphasize context and trade-offs. Research shows students learn best when they compare pattern and non-pattern solutions side-by-side, so design activities that make these comparisons explicit and discussable.

What to Expect

By the end of these activities, students will confidently identify when a pattern fits a problem and justify their choices with clear reasoning. They will also recognize the trade-offs of using patterns, such as added complexity or flexibility, and communicate these insights in discussions and written reflections.

Watch Out for These Misconceptions

Common Misconception

During Pair Programming: Singleton Implementation, watch for students who believe the Singleton pattern should be used in every project that needs a single object.

What to Teach Instead

Ask pairs to refactor their code into a non-pattern version and compare the two, highlighting how the Singleton adds complexity. Have them present one scenario where the pattern is useful and one where it is not.

Common Misconception

During Small Groups: Factory Pattern Challenge, watch for students who copy the pattern exactly without adapting it to their specific problem.

What to Teach Instead

Challenge groups to modify their factory to handle an additional product type or to add validation rules, demonstrating flexibility rather than rote application.

Common Misconception

During Whole Class: Pattern Critique Debate, watch for students who assume patterns are only for large-scale software.

What to Teach Instead

Have students share examples of how patterns could simplify their own small projects, such as a homework tracker or game character system, and discuss the benefits in a real-world context.

Assessment Ideas

Quick Check

After Pair Programming: Singleton Implementation, present students with two short code snippets (one using Singleton, one not) and ask them to explain which one enforces a single instance and why the other fails to do so.

Discussion Prompt

During Whole Class: Pattern Critique Debate, listen for students to articulate at least one drawback of the Singleton pattern in a scenario where multiple independent parts of a program need unique configurations, such as game settings or user profiles.

Exit Ticket

After Individual: Pattern Hunt in Code, ask students to write one problem the Factory pattern solves and describe how it solves it in one sentence, using a code example they found during the activity.

Extensions & Scaffolding

• Challenge: Ask students who finish early to refactor their Factory Pattern implementation to support a new product type without modifying existing client code.
• Scaffolding: For students struggling with the Singleton activity, provide a partially completed class with clear comments guiding where to add the private constructor and static instance.
• Deeper exploration: Have students research and present on the difference between the Factory Method and Abstract Factory patterns, using code examples to illustrate their findings.

Key Vocabulary

Design Pattern	A general, reusable solution to a commonly occurring problem within a given context in software design. Patterns are not finished designs but templates for how to solve problems.
Singleton Pattern	Ensures that a class has only one instance and provides a global point of access to it. Useful for managing shared resources like database connections.
Factory Pattern	Defines an interface for creating an object, but lets subclasses decide which class to instantiate. It promotes loose coupling by separating the creation logic from the client code.
Creational Patterns	A category of design patterns focused on object creation mechanisms, trying to create objects in a manner suitable to the situation. Singleton and Factory are examples.
Structural Patterns	A category of design patterns concerned with class and object composition. The Decorator pattern, which adds responsibilities to objects dynamically, is an example.