FAQ on Software Engineering (Unit 5)
In software engineering, risk refers to the possibility of an unwanted event occurring that can negatively affect the success of a software project.
- It is an uncertain event or condition that, if it occurs, has a positive or negative impact on project objectives like time, cost, quality, or performance.
- Risks can arise from many areas such as technology, people, processes, requirements, environment, or business.
👉 Examples of risks involved in software development:
- Key developer leaving the project (people risk)
- Technology newly introduced, not working as expected (technical risk)
- Sudden changes in customer requirements (requirement risk)
- Delay in hardware/software delivery (scheduled risk)
To deal with risks, software engineers use two main strategies: Reactive and Proactive.
1. Reactive Risk Strategy ("Fix-it-later approach")- In Reactive approach, no major effort is made to identify or plan for risks beforehand. This approach is also called as the crisis management approach.
- Risks are addressed only after they occur in Reactive Risk management that often leads to cost overruns and delays.
👉 Example: A project team that does not anticipate the risk of a developer leaving.
When a developer suddenly quits, the team scrambles to reassign tasks and train a replacement, causing project delays.
- In Proactive strategy of risk management, risks are identified, analyzed, and planned for before they occur.
- The team develops risk management plans, including mitigation and contingency strategies. This minimizes damage and increases project stability.
👉 Example: The project team that anticipates a key developer leave.
A proactive team cross-train other team members and document code thoroughly. When the developer actually resigns, the impact is minimal, and the project continues smoothly.
Question 2:
- In Software Engineering, risk refers to the possibility of an undesirable event that can negatively impact the successful completion of a software project.
- Software risk refers to the probability of loss combined with the consequences of that loss that may occur during the development of software
- Software risks can arise from people, process, technology, business, or external factors.
- Identifying, analyzing, and managing these risks early is crucial to ensure software projects finish on time, within budget, and with good quality.
A risk usually has three main components:
- Uncertainty – The risk may or may not happen.
- Loss – If the risk occurs, it can cause negative effects (cost, time, performance, quality, etc.).
- Impact – The severity of damage it can cause to the project or organization.
👉 Example:
- If requirements are not properly understood (uncertainty), the software may not satisfy user needs (loss), leading to project failure (impact).
Types of Software Risks:
Risks in software development can be categorized in different ways. A widely used classification is:
1. Project Risks
- Related to the environment in which the project is being developed.
- They affect schedule, resources, cost, and people.
- Examples:
- Unrealistic deadlines.
- Inadequate budget allocation.
- Lack of skilled developers/testers.
- Poor communication among team members.
2. Technical Risks
- Related to the technology used in the project.
- They threaten the quality, performance, or functionality of the software.
- Examples:
- Use of new or unproven technology.
- Integration issues with third-party tools or systems.
- Technical complexity not well understood.
- Performance or scalability failures.
3. Business Risks
- Associated with the market or business impact of the software product.
- Examples:
- Product fails to meet user needs.
- Competitors release better software earlier.
- Change in business priorities.
- Customer may cancel the project.
4. Operational Risks
- Risks that affect the daily operation and support of the software.
- Examples:
- Inadequate maintenance plan.
- Poor documentation for users or developers.
- System downtime or data loss after release.
5. External Risks
- Risks beyond the control of the project team.
- Examples:
- Changes in government regulations or legal policies.
- Natural disasters (flood, earthquake).
- Market changes due to new competitors.
6. Schedule Risks
- Directly related to time management of the project.
- Examples:
- Wrong effort estimation.
- Unexpected delays in key tasks.
- Dependency on external vendors or clients causing slippage.
7. Cost Risks
- Related to budget overrun and financial mismanagement.
- Examples:
- Underestimation of total development cost.
- Increase in hardware/software licensing fees.
- Unexpected resource requirement.
Question 3:
Briefly explain the steps involved in risk planning for software development.
Risk planning in software development involves identifying, analyzing, and preparing strategies to manage potential risks that could affect the project. The key steps are:
-
Risk Identification:
List all possible risks that could impact the project — such as technical failures, cost overruns, schedule delays, or resource issues. -
Risk Analysis:
Evaluate each identified risk to determine its likelihood (probability of occurrence) and impact (effect on project objectives). -
Risk Prioritization:
Rank risks based on their severity (a combination of likelihood and impact) to focus on the most critical ones. -
Risk Response Planning:
Develop strategies to handle each major risk. Common strategies include:- Avoidance: Change plans to eliminate the risk.
- Mitigation: Reduce the likelihood or impact.
- Transfer: Shift responsibility (e.g., insurance or outsourcing).
- Acceptance: Acknowledge the risk and prepare contingency plans.
-
Risk Monitoring and Control:
Continuously track identified risks, detect new ones, and update risk plans throughout the project lifecycle.
These steps help ensure that risks are managed proactively, improving the project’s chances of success.
