Software Design Principles

Students remember software design principles when they apply them actively rather than study abstract definitions. These concepts transform from theory to tools when students refactor messy code, analyze dependencies, and build modular systems with their own hands. Active learning turns confusion about cohesion and coupling into clear choices they can defend.

• Grade 12
• Computer Science
• 4 activities
• 35 min–60 min

Learning Objectives

1. Design a class structure for a simple application, applying principles of high cohesion and low coupling.
2. Analyze a given code module to identify areas where cohesion can be increased or coupling can be decreased.
3. Explain how modularity and abstraction contribute to the maintainability and scalability of software systems.
4. Compare and contrast different design patterns (e.g., Singleton, Factory) in terms of their application and impact on code structure.
5. Critique a software design for potential issues related to tight coupling or low cohesion, suggesting specific refactoring steps.

Concept Mapping

⏱ 35 min·Pairs

Pairs Refactor: Cohesion Challenge

Give pairs a code snippet with mixed responsibilities, like a class handling both data storage and user interface. They identify issues, separate functions into cohesive modules, and test the refactored version. Pairs then swap with another duo for feedback.

Prepare & details

Explain how modularity and abstraction contribute to robust software design.

Facilitation Tip: During Pairs Refactor: Cohesion Challenge, circulate and ask each pair to verbalize one rule they applied while splitting their class into smaller, focused components.

Setup: Tables with large paper, or wall space

Materials: Concept cards or sticky notes, Large paper, Markers, Example concept map

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

Concept Mapping

⏱ 45 min·Small Groups

Small Groups: Coupling Hunt

Distribute code examples with varying coupling levels to small groups. Groups diagram dependencies, propose decoupling via interfaces or events, and rewrite one snippet. Groups share strategies in a class debrief.

Prepare & details

Differentiate between high cohesion and low coupling in software modules.

Facilitation Tip: For Small Groups: Coupling Hunt, provide a printed class diagram so groups can physically circle and untangle dependencies with colored markers.

Setup: Tables with large paper, or wall space

Materials: Concept cards or sticky notes, Large paper, Markers, Example concept map

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

Concept Mapping

⏱ 60 min·Whole Class

Whole Class: Modular App Build

Assign class roles to build a simple inventory app modularly: one team on data module, another on UI, others on business logic. Teams integrate via defined interfaces, then demo the full system.

Prepare & details

Design a class structure for a simple application, applying object-oriented design principles.

Facilitation Tip: In Whole Class: Modular App Build, assign rotating roles like ‘interface designer’ and ‘implementation reviewer’ to keep all students engaged in the construction process.

Setup: Tables with large paper, or wall space

Materials: Concept cards or sticky notes, Large paper, Markers, Example concept map

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

Concept Mapping

⏱ 50 min·Individual

Individual: Pattern Application

Students pick a design pattern like Observer, sketch a class diagram for a chat app scenario, implement core code, and note cohesion and coupling benefits. Submit with a short rationale.

Prepare & details

Explain how modularity and abstraction contribute to robust software design.

Facilitation Tip: For Individual: Pattern Application, supply a checklist of pattern characteristics so students self-assess before submitting their final code.

Setup: Tables with large paper, or wall space

Materials: Concept cards or sticky notes, Large paper, Markers, Example concept map

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

Teaching This Topic

Teach these principles through cycles of broken code, guided fixes, and reflection rather than lectures. Start with a flawed example students immediately recognize as hard to maintain, then model refactoring step-by-step while naming each principle aloud. Avoid overwhelming beginners with too many patterns at once; focus on one or two patterns per unit and connect them to cohesion and coupling concepts. Research shows students grasp abstraction best when they experience complexity firsthand before simplifying it into clear interfaces.

What to Expect

Students will confidently identify high-cohesion and low-coupling structures in code, explain why modularity matters, and adapt design patterns to solve real problems. They will discuss trade-offs with peers and justify their design decisions using clear terminology. Successful learners will also spot and fix common anti-patterns in sample code.

Watch Out for These Misconceptions

Common Misconception

During Pairs Refactor: Cohesion Challenge, watch for students combining unrelated methods into one ‘all-purpose’ class.

What to Teach Instead

Circulate and ask each pair to defend the grouping of methods in their class; if they struggle, prompt them to consider the single responsibility principle and suggest splitting the class into smaller, role-specific modules.

Common Misconception

During Small Groups: Coupling Hunt, watch for students equating low coupling with zero interactions between modules.

What to Teach Instead

Ask groups to map dependencies on paper and highlight which connections are necessary; guide them to convert direct method calls into interfaces or events to reduce tight coupling.

Common Misconception

During Individual: Pattern Application, watch for students applying patterns rigidly without adapting to context.

What to Teach Instead

Require students to include a short justification note with each pattern, explaining why it fits the problem and how it improves cohesion or reduces coupling in their specific scenario.

Assessment Ideas

Quick Check

After Pairs Refactor: Cohesion Challenge, present two revised class snippets and ask students to identify which shows higher cohesion and explain their choice using the single responsibility principle.

Discussion Prompt

During Whole Class: Modular App Build, pose a scenario where a module must change and ask the class to predict the impact of coupling decisions made during their build, prompting them to articulate dependency risks.

Peer Assessment

After Individual: Pattern Application, have students swap code with a partner and complete a feedback form identifying one cohesion issue and one coupling improvement, then discuss findings as a class.

Extensions & Scaffolding

• Challenge: Ask early finishers to adapt their design to support a new feature without modifying existing classes, demonstrating the Open/Closed Principle.
• Scaffolding: Provide pre-labeled class diagrams with blanks for students to fill in the correct relationships or responsibilities.
• Deeper exploration: Invite students to research real-world systems (e.g., game engines or e-commerce platforms) and present how they apply modularity and design patterns.

Key Vocabulary

Modularity	The degree to which a system's components may be separated and recombined. It involves breaking down a large system into smaller, independent, and interchangeable parts.
Abstraction	The process of hiding complex implementation details and exposing only the essential features of an object or system. It simplifies interaction by focusing on what an entity does, not how it does it.
Cohesion	A measure of how closely related and focused the responsibilities of a module or class are. High cohesion means a module does one thing well.
Coupling	A measure of the degree of interdependence between software modules. Low coupling means modules are independent and changes in one have minimal impact on others.
Design Pattern	A reusable solution to a commonly occurring problem within a given context in software design. Patterns provide a blueprint for how to structure code.