Maintenance and Support

Active learning works well for maintenance and support because this topic requires students to engage with the messy, iterative reality of software rather than idealized development. Students need hands-on practice analyzing incomplete systems, making judgment calls with imperfect information, and experiencing the consequences of their decisions.

• 11th Grade
• Computer Science
• 4 activities
• 25 min–40 min

Learning Objectives

1. Classify software maintenance tasks into corrective, adaptive, and perfective categories based on provided scenarios.
2. Analyze the potential long-term costs and challenges associated with neglecting software maintenance for a given application.
3. Design a tiered support plan for a hypothetical software application, outlining response times and escalation procedures for different issue severities.
4. Evaluate the trade-offs between patching existing software and developing a new solution when faced with obsolescence or significant bugs.
5. Synthesize user feedback and system logs to propose specific perfective maintenance improvements for a software product.

Role Play

⏱ 40 min·Small Groups

Role Play: Maintenance Triage

Groups receive a backlog of ten fictional bug reports and feature requests for a deployed app. Teams must categorize each item (corrective, adaptive, or perfective), assign a priority, and estimate relative effort. Groups then compare their triage decisions and defend their prioritization to the class.

Prepare & details

Explain the different types of software maintenance (e.g., corrective, adaptive, perfective).

Facilitation Tip: During the Maintenance Triage role play, provide students with sticky notes in three colors to physically sort scenarios into corrective, adaptive, or perfective maintenance categories.

Setup: Open space or rearranged desks for scenario staging

Materials: Character cards with backstory and goals, Scenario briefing sheet

• Apply
• Analyze
• Evaluate
• Social Awareness
• Self-Awareness

Think-Pair-Share

⏱ 25 min·Pairs

Think-Pair-Share: Legacy Code Analysis

Students individually read a short, unfamiliar code snippet and list everything they would need to understand before safely modifying it: dependencies, assumptions, side effects, and undocumented behavior. Partners compare lists and identify the most critical unknowns before sharing with the class.

Prepare & details

Analyze the challenges of long-term software maintenance and support.

Facilitation Tip: For Legacy Code Analysis, give students 10 minutes to silently annotate a provided code snippet with questions and concerns before discussing in pairs.

Setup: Standard classroom seating; students turn to a neighbor

Materials: Discussion prompt (projected or printed), Optional: recording sheet for pairs

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

Structured Academic Controversy

⏱ 35 min·Pairs

Structured Academic Controversy: Patch vs. Rewrite

Present a scenario: a five-year-old system that works but is difficult to maintain. Pairs argue for incremental patching, then switch to argue for a full rewrite, before synthesizing a recommendation. Debrief focuses on what information would change the decision.

Prepare & details

Design a basic support plan for a deployed software application.

Facilitation Tip: In the Patch vs. Rewrite structured controversy, assign roles explicitly and require students to argue from the assigned perspective for two minutes before switching.

Setup: Pairs of desks facing each other

Materials: Position briefs (both sides), Note-taking template, Consensus statement template

• Analyze
• Evaluate
• Create
• Social Awareness
• Relationship Skills

Gallery Walk

⏱ 30 min·Small Groups

Gallery Walk: Support Plan Designs

Groups draft a basic support plan for their capstone project covering bug reporting, update frequency, dependency monitoring, and end-of-life. Plans are posted and peers leave sticky notes identifying gaps or risks the team did not consider.

Prepare & details

Explain the different types of software maintenance (e.g., corrective, adaptive, perfective).

Facilitation Tip: During the Support Plan Gallery Walk, post guiding questions on the walls and ask students to add sticky-note comments to each plan as they circulate.

Setup: Wall space or tables arranged around room perimeter

Materials: Large paper/poster boards, Markers, Sticky notes for feedback

• Understand
• Apply
• Analyze
• Create
• Relationship Skills
• Social Awareness

Teaching This Topic

Teachers should treat maintenance as a mindset shift rather than a technical skill. Avoid presenting maintenance as a lesser form of development. Instead, emphasize the problem-solving nature of working with legacy systems and the importance of documentation as a communication tool. Research shows that students grasp maintenance concepts better when they experience the frustration of unclear code or broken dependencies firsthand.

What to Expect

Successful learning looks like students recognizing maintenance as an ongoing, skilled process rather than a one-time task, and confidently categorizing maintenance needs and proposing solutions. They should articulate why maintenance requires different skills than writing new code, and design basic support frameworks that address real-world constraints.

Watch Out for These Misconceptions

Common Misconception

During Role Play: Maintenance Triage, watch for students defaulting to 'bug fixing' as the only maintenance type. Redirect them to consider how operating system updates or new user requests change software needs.

What to Teach Instead

After distributing scenarios, ask students to identify which maintenance type each represents before they begin role-playing, and require them to justify their choices using the scenario details.

Common Misconception

During Think-Pair-Share: Legacy Code Analysis, watch for students assuming well-written code requires no maintenance. Redirect them to examine dependencies and environment changes.

What to Teach Instead

Provide student pairs with a legacy code snippet that includes hardcoded file paths or deprecated API calls, and ask them to identify what would break if the operating system or libraries were updated.

Common Misconception

During Structured Academic Controversy: Patch vs. Rewrite, watch for students dismissing patching as inferior work. Redirect them to consider the risks and costs of each approach.

What to Teach Instead

Require students to calculate estimated hours for both patching and rewriting during their debate, using provided scenarios that include user base size and criticality of the feature.

Assessment Ideas

Quick Check

After Role Play: Maintenance Triage, present students with three brief descriptions of software issues. Ask them to identify which type of maintenance each scenario represents and briefly explain their reasoning, then collect responses to check for accuracy.

Discussion Prompt

During Think-Pair-Share: Legacy Code Analysis, pose the question: 'Imagine your capstone project software is now five years old. What are three specific challenges you might face in keeping it running smoothly, and how would you address them?' Facilitate a class discussion on their responses, noting whether students identify adaptive, corrective, or perfective maintenance needs.

Peer Assessment

After Gallery Walk: Support Plan Designs, have students draft a basic support plan for a simple application they developed. They then exchange plans with a partner and provide feedback using a checklist: Does the plan include contact information? Are issue severity levels defined? Is there a clear escalation path? Partners sign off on feedback provided.

Extensions & Scaffolding

• Challenge: Ask students to research a real-world software failure caused by poor maintenance and prepare a 2-minute presentation on how it could have been prevented.
• Scaffolding: Provide sentence starters for the Legacy Code Analysis activity, such as "I notice..." and "This might cause problems because..."
• Deeper exploration: Have students interview a local software developer about maintenance challenges they face and report back to the class.

Key Vocabulary

Corrective Maintenance	The process of fixing defects or bugs discovered in software after it has been deployed to users.
Adaptive Maintenance	Modifying software to remain functional and compatible with changes in its operating environment, such as new operating systems or hardware.
Perfective Maintenance	Enhancing software performance, usability, or adding new features based on user feedback or evolving requirements.
Software Obsolescence	The state where software components or the entire application become outdated, unsupported, or incompatible with modern systems.
Support Plan	A document outlining the strategy for providing assistance to users of a software application, including issue reporting, response times, and resolution processes.