Software reengineering in Software Engineering - Mini Project: Build & Apply

Understanding Software Reengineering

📖 Scenario: You work in a software company that has an old application. The company wants to improve it without starting from scratch. You will learn how to organize the steps to reengineer the software.

🎯 Goal: Build a clear step-by-step plan that shows the main phases of software reengineering. This plan will help your team understand what to do to improve the old software.

📋 What You'll Learn

Create a list called reengineering_phases with the main phases of software reengineering in order.

Add a variable called current_phase_index to track which phase the team is working on.

Use a for loop with variables index and phase to go through each phase and mark the current one.

Add a final statement that shows the project is ready to start reengineering.

💡 Why This Matters

🌍 Real World

Software reengineering helps companies improve old software systems by updating or restructuring them instead of building new ones from scratch.

💼 Career

Understanding software reengineering phases is important for software engineers, project managers, and quality assurance professionals involved in maintaining and improving legacy systems.

1

DATA SETUP: Create the list of software reengineering phases

Create a list called reengineering_phases with these exact phases in order: 'Inventory Analysis', 'Document Restructuring', 'Reverse Engineering', 'Program Restructuring', 'Forward Engineering'.

Software Engineering

# Create the list reengineering_phases with the given phases
# Your code here

Hint

Use square brackets [] to create a list and separate each phase with commas.

2

CONFIGURATION: Add a variable to track the current phase

Add a variable called current_phase_index and set it to 0 to represent the first phase in the list.

Software Engineering

reengineering_phases = ['Inventory Analysis', 'Document Restructuring', 'Reverse Engineering', 'Program Restructuring', 'Forward Engineering']
# Add current_phase_index variable below
# Your code here

Hint

Set current_phase_index to zero because list indexes start at zero.

3

CORE LOGIC: Loop through phases and mark the current one

Use a for loop with variables index and phase to go through reengineering_phases using enumerate(). Inside the loop, check if index equals current_phase_index. If yes, create a variable status with value '(current phase)', else set status to an empty string ''. This marks the current phase.

Software Engineering

reengineering_phases = ['Inventory Analysis', 'Document Restructuring', 'Reverse Engineering', 'Program Restructuring', 'Forward Engineering']
current_phase_index = 0
# Loop through phases and mark the current one
# Your code here

Hint

Use enumerate() to get both index and phase. Use an if statement to compare index and current_phase_index.

4

COMPLETION: Add a final statement to show readiness

Add a variable called project_ready and set it to True to indicate the software reengineering project is ready to start.

Software Engineering

reengineering_phases = ['Inventory Analysis', 'Document Restructuring', 'Reverse Engineering', 'Program Restructuring', 'Forward Engineering']
current_phase_index = 0
for index, phase in enumerate(reengineering_phases):
    if index == current_phase_index:
        status = '(current phase)'
    else:
        status = ''
# Set project_ready to True
# Your code here

Hint

Use a simple assignment to set project_ready to True.

Practice

1. What is the main goal of software reengineering?

easy

A. To create new software from scratch

B. To increase the number of software users

C. To delete outdated software permanently

D. To improve old software for easier maintenance and extension

Solution

1. Step 1: Understand the purpose of software reengineering

   Software reengineering focuses on improving existing software, not creating new software or deleting it.

2. Step 2: Identify the main benefit

   The main benefit is making old software easier to maintain and extend.

3. Final Answer:

   To improve old software for easier maintenance and extension -> Option D

4. Quick Check:

   Software reengineering = Improve old software [OK]

Hint: Focus on improving existing software, not creating new [OK]

Common Mistakes:

• Confusing reengineering with new software development
• Thinking it means deleting software
• Assuming it increases user base directly

2. Which of the following is a common step in software reengineering?

easy

A. Analyzing and restructuring existing code

B. Writing new software without reviewing old code

C. Deleting all old documentation

D. Ignoring software bugs

Solution

1. Step 1: Identify typical reengineering activities

   Reengineering involves analyzing and restructuring existing code to improve it.

2. Step 2: Eliminate incorrect options

   Writing new software without review, deleting documentation, or ignoring bugs are not part of reengineering.

3. Final Answer:

   Analyzing and restructuring existing code -> Option A

4. Quick Check:

   Reengineering step = Analyze and restructure code [OK]

Hint: Look for options about improving existing code [OK]

Common Mistakes:

• Choosing options about creating new software
• Ignoring the importance of analysis
• Confusing reengineering with software removal

3. Consider a software system that is outdated but still valuable. Which reengineering approach is most suitable?

medium

A. Software reverse engineering and restructuring

B. Complete rewrite from scratch

C. Ignoring the system and building a new one

D. Deleting the system immediately

Solution

1. Step 1: Understand the system condition

   The system is outdated but valuable, so it should be improved, not discarded.

2. Step 2: Choose the best reengineering approach

   Reverse engineering and restructuring help understand and improve the existing system without starting over.

3. Final Answer:

   Software reverse engineering and restructuring -> Option A

4. Quick Check:

   Outdated but valuable = Reverse engineering [OK]

Hint: Use reverse engineering for valuable outdated software [OK]

Common Mistakes:

• Choosing complete rewrite which is costly
• Ignoring the system instead of improving
• Deleting valuable software

4. A developer tries to reengineer software but skips analyzing the existing code. What is the likely problem?

medium

A. The software will be deleted

B. The reengineering will miss important design issues

C. The software will run faster without analysis

D. The software will automatically improve

Solution

1. Step 1: Understand the role of code analysis in reengineering

   Analyzing existing code helps find design problems and areas to improve.

2. Step 2: Predict consequences of skipping analysis

   Without analysis, important issues remain hidden, causing poor reengineering results.

3. Final Answer:

   The reengineering will miss important design issues -> Option B

4. Quick Check:

   Skip analysis = Miss design issues [OK]

Hint: Never skip code analysis in reengineering [OK]

Common Mistakes:

• Assuming software improves automatically
• Thinking skipping analysis speeds software
• Confusing deletion with reengineering

5. You have a legacy software with duplicated code and outdated modules. Which reengineering strategy best improves maintainability?

hard

A. Adding more duplicated code for backup

B. Deleting all old modules without replacement

C. Refactoring duplicated code and modularizing outdated parts

D. Ignoring the code quality and adding new features

Solution

1. Step 1: Identify problems in legacy software

   Duplicated code and outdated modules reduce maintainability and increase errors.

2. Step 2: Choose reengineering strategy to improve maintainability

   Refactoring removes duplication and modularizing updates old parts, making maintenance easier.

3. Final Answer:

   Refactoring duplicated code and modularizing outdated parts -> Option C

4. Quick Check:

   Fix duplication + modularize = better maintainability [OK]

Hint: Refactor duplicates and modularize outdated code [OK]

Common Mistakes:

• Deleting modules without replacement
• Adding more duplicated code
• Ignoring code quality issues