Computer Science · Grade 12 · Software Engineering Principles · Term 4

Software Design Principles

Learning about design patterns, modularity, cohesion, and coupling for creating maintainable and scalable code.

• Ontario Curriculum Expectations
• CS.SE.8
• CS.P.24

About This Topic

Software design principles equip Grade 12 students with tools to build maintainable and scalable code, focusing on design patterns, modularity, cohesion, and coupling. Students learn modularity divides systems into independent components, abstraction simplifies complexity by hiding details, high cohesion groups related functions tightly, and low coupling reduces dependencies between modules. These concepts directly address curriculum key questions, such as explaining modularity and abstraction's role in robust design, differentiating cohesion from coupling, and creating class structures for applications using object-oriented principles.

This topic fits within Ontario's Computer Science standards for software engineering, linking to real-world practices where solid design prevents code from becoming unmanageable as projects grow. Students analyze how poor cohesion leads to tangled logic and high coupling causes ripple effects from changes, building essential skills for collaborative development and debugging.

Active learning benefits this topic greatly because students grasp abstract ideas through hands-on coding. Refactoring exercises and peer code reviews let them see poor design's pitfalls firsthand, experiment with improvements, and iterate toward professional standards, making principles stick through trial and reflection.

Key Questions

1. Explain how modularity and abstraction contribute to robust software design.
2. Differentiate between high cohesion and low coupling in software modules.
3. Design a class structure for a simple application, applying object-oriented design principles.

Learning Objectives

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

Before You Start

Object-Oriented Programming Fundamentals

Why: Students must understand concepts like classes, objects, encapsulation, and inheritance to effectively apply design principles.

Basic Data Structures

Why: Knowledge of arrays, lists, and other data structures is helpful for understanding how data is organized within modules and how modules interact.

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.

Watch Out for These Misconceptions

Common Misconception

High cohesion requires all code in one class.

What to Teach Instead

Cohesion means related elements together, but modularity favors small, focused classes. Peer reviews in group refactoring help students spot bloated classes and practice splitting them logically.

Common Misconception

Low coupling means no module interactions.

What to Teach Instead

Modules need controlled interactions via clear interfaces; total isolation is impractical. Active analysis of code graphs in pairs reveals unnecessary ties and teaches minimal dependency strategies.

Common Misconception

Design patterns solve every problem instantly.

What to Teach Instead

Patterns guide flexible solutions, not rigid fixes. Hands-on projects where students adapt patterns iteratively show context matters, building discernment through trial and classmate input.

Active Learning Ideas

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.

35 min·Pairs

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.

45 min·Small Groups

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.

60 min·Whole Class

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.

50 min·Individual

Real-World Connections

• Software engineers at Google use design patterns like the Observer pattern to manage updates in real-time data feeds for services like Google Maps, ensuring efficient communication between different application components.
• Game developers at Ubisoft employ modular design principles when building large open-world games like Assassin's Creed. This allows different teams to work on distinct game systems (e.g., combat, AI, environment) independently, improving development speed and code manageability.
• Financial institutions like RBC use highly cohesive and loosely coupled modules for their online banking platforms. This separation of concerns, for example, between user authentication and transaction processing, enhances security and allows for easier updates to individual features without affecting the entire system.

Assessment Ideas

Quick Check

Present students with two short code snippets, one demonstrating high cohesion and low coupling, the other demonstrating the opposite. Ask students to identify which snippet is better designed and provide one specific reason, referencing cohesion or coupling.

Discussion Prompt

Facilitate a class discussion using the prompt: 'Imagine you are building a system to manage a library. How would you use modularity and abstraction to design the core components, such as cataloging books and managing user accounts? What are potential pitfalls if these modules become too tightly coupled?'

Peer Assessment

Assign students to design a simple class structure for a 'Smart Home Device' application. After they complete their initial design, have them swap with a partner. Each student reviews their partner's design, looking for opportunities to improve cohesion or reduce coupling, and provides one specific suggestion for refactoring.

Frequently Asked Questions

How do I teach cohesion and coupling effectively in Grade 12 CS?

Start with visual analogies, like a kitchen where cohesion keeps tools together by task and coupling links via shared counters minimally. Follow with code examples: dissect a monolithic class for cohesion flaws, then trace change impacts for coupling. Assign paired refactoring to reinforce, as students quantify improvements in test runs and discussions, aligning with Ontario standards for practical software engineering.

What design patterns are best for introducing software principles?

Begin with Singleton for resource control, Observer for event handling, and Factory for object creation, as they illustrate modularity clearly. Tie to cohesion by showing pattern classes with single purposes and low coupling through interfaces. Provide starter code for students to extend, ensuring patterns support scalable apps like games or tools, per CS.SE.8 expectations.

How does modularity contribute to scalable software design?

Modularity allows independent scaling of components, like updating a payment module without touching user auth. It promotes abstraction, hiding details for easier maintenance. In class designs, students see how it reduces bugs from changes, supports team work, and aligns with key questions on robust OOP, preparing for real projects in Term 4.

How can active learning help students master software design principles?

Active approaches like paired refactoring and group app builds make cohesion, coupling, and patterns tangible. Students refactor real code, observe failure modes, and measure gains in readability or speed, far beyond lectures. Collaborative critiques build peer teaching, while iterative projects mirror industry, boosting retention and confidence for Ontario's CS.P.24 standards on practical design.