Refactoring and Code Quality

Active learning works especially well for refactoring because students must see code smells firsthand and feel the impact of structural changes. Working with messy examples forces them to confront readability issues directly instead of just hearing about them. Students retain best when they practice fixes on real code, not abstract slides.

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

Learning Objectives

1. Analyze common code smells in provided code snippets, identifying specific indicators of poor quality.
2. Evaluate the impact of specific refactoring techniques on code readability and maintainability.
3. Design a refactoring plan for a given code segment, outlining the steps to improve its structure and clarity.
4. Compare the efficiency of different code implementations for the same task before and after refactoring.
5. Critique refactored code, assessing whether external behavior has been preserved and quality has improved.

Case Study Analysis

⏱ 30 min·Pairs

Pair Refactor: Messy Method Challenge

Provide pairs with a long, duplicated function handling student grades. Partners identify issues like poor naming and redundancy, then refactor into smaller methods over 10 minutes. Pairs test outputs match originals and share one key change with the class.

Prepare & details

Analyze the characteristics of 'bad code' and how refactoring addresses them.

Facilitation Tip: During Personal Project Polish, remind students to commit their original messy version before refactoring so they can compare changes later.

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

Stations Rotation

⏱ 45 min·Small Groups

Stations Rotation: Refactoring Types

Set up stations for extract method, rename variables, remove duplication, and simplify conditionals. Small groups spend 7 minutes per station refactoring code cards, recording before-and-after versions. Groups rotate and compare results in a final debrief.

Prepare & details

Explain the importance of maintaining code quality in long-term software projects.

Setup: Tables/desks arranged in 4-6 distinct stations around room

Materials: Station instruction cards, Different materials per station, Rotation timer

• Remember
• Understand
• Apply
• Analyze
• Self-Management
• Relationship Skills

Case Study Analysis

⏱ 35 min·Whole Class

Whole Class: Code Quality Debate

Display two code versions solving the same task. Class votes on quality, then discusses refactoring opportunities in real time. Students propose changes via shared editor, vote on best ones, and implement as a group.

Prepare & details

Design a refactoring strategy for a given piece of inefficient or hard-to-read code.

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

⏱ 40 min·Individual

Individual: Personal Project Polish

Students select a prior unit's code project. They apply three refactoring techniques independently, document changes in a log, and self-assess using a quality rubric. Share one improvement in a quick gallery walk.

Prepare & details

Analyze the characteristics of 'bad code' and how refactoring addresses them.

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

Start by showing students a poorly written method and having them articulate why it is hard to follow. Model the refactoring process step by step while narrating your decisions about names and structure. Emphasize that good code reads like clear instructions, not a puzzle. Avoid teaching refactoring as a set of rules to memorize; instead, connect each technique to concrete benefits like shorter debugging time or easier collaboration. Research shows students grasp concepts better when they see the immediate payoff of their work.

What to Expect

Students should demonstrate the ability to identify code smells, apply at least two refactoring techniques, and explain how their changes improve maintainability without altering behavior. They should also justify their choices during discussions and peer reviews. Evidence of learning appears in their refactored code and their ability to critique alternatives.

Watch Out for These Misconceptions

Common Misconception

During Pair Refactor, watch for students who assume refactoring changes program output. Redirect them to test outputs before and after changes to confirm behavior stays the same.

What to Teach Instead

During Pair Refactor, students will encounter code smells like duplicated logic or long methods. Redirect their attention to how clear variable names and modular functions make the code easier to follow without changing what it does.

Common Misconception

During Station Rotation, watch for students who believe adding more comments fixes messy code. Redirect them to examine how well-named variables and methods reduce the need for comments.

What to Teach Instead

During Code Quality Debate, students may claim that comments are always necessary. Redirect the discussion by having them compare heavily commented code with self-documenting code they refactored earlier.

Common Misconception

During Personal Project Polish, watch for students who see refactoring only as a bug-fixing tool. Redirect them to focus on structure improvements that prevent future bugs.

What to Teach Instead

During Personal Project Polish, students might treat refactoring as a last-minute fix. Redirect them to identify areas where small structural changes now will save time later in the project lifecycle.

Assessment Ideas

Quick Check

After Pair Refactor, present students with a short code snippet exhibiting a common code smell (e.g., duplicated code). Ask them to identify the smell and write one sentence explaining why it is problematic.

Discussion Prompt

After Code Quality Debate, pose the question: 'Imagine you are joining a project with a large, existing codebase. What are the first three things you would look for to assess its quality and identify areas for refactoring?' Facilitate a class discussion on their responses.

Peer Assessment

During Pair Refactor, after students swap their original and refactored versions, have each student write two bullet points: one positive comment about their partner's refactored code and one suggestion for further improvement.

Extensions & Scaffolding

• Challenge: Ask students to refactor a larger codebase by extracting classes or methods they identify as missing.
• Scaffolding: Provide a partially completed refactoring checklist with blanks for students to fill in as they work.
• Deeper exploration: Have students document their refactoring process in a short reflection, explaining how their changes improve maintainability.

Key Vocabulary

Code Smell	A surface indication in the source code that potentially points to a deeper problem. Examples include duplicated code or long methods.
Refactoring	The process of restructuring existing computer code without changing its external behavior. It aims to improve non-functional attributes of the software.
Readability	The ease with which human readers can comprehend the purpose, structure, and operation of source code. Clear naming and formatting contribute to readability.
Maintainability	The ease with which software can be modified to correct defects, improve performance, or adapt to a changed environment. Well-structured code is more maintainable.
Duplicated Code	Identical or very similar code structures appearing in multiple places within a program. This violates the 'Don't Repeat Yourself' principle.