2019 question paper

Software Engineering

18 questions

Q1a. The spiral model was originally proposed by: (i) IBM (ii) Barry Boehm (iii) Pressman (iv) Royce20192m
Module 1: Introduction & SDLC
The spiral model was originally proposed by:
(i) IBM
(ii) Barry Boehm
(iii) Pressman
(iv) Royce

View this question on its own page →
Search Google Ask AI
Worked Solution
Answer

(ii) Barry Boehm

Explanation

The Spiral Model was proposed by Barry Boehm. It is a risk-driven software development model that combines iterative development with systematic aspects of the waterfall model.

Final answer: (ii) Barry Boehm
Q1b. In what type of coupling, the complete data structure is passed from one module to another? (i) Control coupling (ii) External coupling (iii) Stamp coupling (iv) Content coupling20192m
Module 3: Software Design & Metrics
In what type of coupling, the complete data structure is passed from one module to another?
(i) Control coupling
(ii) External coupling
(iii) Stamp coupling
(iv) Content coupling

View this question on its own page →
Search Google Ask AI
Worked Solution
Answer

(iii) Stamp coupling

Explanation

Stamp coupling occurs when one module passes a complete data structure (such as a record or object) to another module, even though the receiving module may need only part of it.

Control coupling → passes control information.

External coupling → depends on externally imposed formats/devices/protocols.

Stamp coupling → passes a composite data structure.

Content coupling → one module directly depends on or modifies another module's internal contents.

Final answer: (iii) Stamp coupling
Q1c. Measure of reliability is given by: (i) Mean time between success (ii) MTBF (iii) Mean reliable (iv) MTTR20192m
Module 4: Software Testing
Measure of reliability is given by:
(i) Mean time between success
(ii) MTBF
(iii) Mean reliable
(iv) MTTR

View this question on its own page →
Search Google Ask AI
Worked Solution
Answer

(ii) MTBF

Explanation

MTBF (Mean Time Between Failures) is a commonly used reliability measure for repairable systems. A higher MTBF generally indicates greater reliability.

MTBF = Total operating time / Number of failures

Final answer: (ii) MTBF
Q1d. Which one of the following is not desired in a good Software Requirement Specifications (SRS) document? (i) Functional requirements (ii) Goals of implementation (iii) Non-functional requirements (iv) Algorithms for software implementation20192m
Module 2: Requirements & SRS
Which one of the following is not desired in a good Software Requirement Specifications (SRS) document?
(i) Functional requirements
(ii) Goals of implementation
(iii) Non-functional requirements
(iv) Algorithms for software implementation

View this question on its own page →
Search Google Ask AI
Worked Solution
Answer

(iv) Algorithms for software implementation

Explanation

An SRS should describe what the software must do, including functional and non-functional requirements. Detailed implementation algorithms describe how the software will be built and therefore generally belong to design/implementation documentation rather than the SRS.

Final answer: (iv) Algorithms for software implementation
Q1e. _____ is a measure of the degree of interdependence between modules. (i) Cohesion (ii) Global variable (iii) Coupling (iv) Call sequence20192m
Module 3: Software Design & Metrics
_____ is a measure of the degree of interdependence between modules.
(i) Cohesion
(ii) Global variable
(iii) Coupling
(iv) Call sequence

View this question on its own page →
Search Google Ask AI
Worked Solution
Answer

(iii) Coupling

Explanation

Coupling measures the degree of interdependence between modules. Good software design aims for low coupling, so that changes in one module have minimal impact on others.

By contrast, cohesion measures how strongly the responsibilities within a single module are related.

Final answer: (iii) Coupling
Q1f. If all tasks must be executed in the same time-span, what type of cohesion is being exhibited? (i) Functional (ii) Spatial (iii) Temporal (iv) Sequential20192m
Module 3: Software Design & Metrics
If all tasks must be executed in the same time-span, what type of cohesion is being exhibited?
(i) Functional
(ii) Spatial
(iii) Temporal
(iv) Sequential

View this question on its own page →
Search Google Ask AI
Worked Solution
Answer

(iii) Temporal cohesion

Explanation

Temporal cohesion occurs when elements of a module are grouped because they must be executed during the same period of time or at the same stage of processing.

For example, a module containing all initialization tasks that must run during system startup exhibits temporal cohesion.

Final answer: (iii) Temporal
Q1g. Independent modules are easier to maintain and test because of: (i) code modification is limited (ii) reusable modules are possible (iii) error propagation is reduced (iv) All of the above20192m
Module 3: Software Design & Metrics
Independent modules are easier to maintain and test because of:
(i) code modification is limited
(ii) reusable modules are possible
(iii) error propagation is reduced
(iv) All of the above

View this question on its own page →
Search Google Ask AI
Worked Solution
Answer

(iv) All of the above

Explanation

Independent modules improve maintainability and testing because:

Changes are more localized, so code modification is limited.

Well-defined modules can often be reused.

Faults are less likely to spread across module boundaries, so error propagation is reduced.

Therefore all three statements are valid.

Final answer: (iv) All of the above
Q1h. From the following, which quality deals with maintaining the quality of the software product? (i) Quality assurance (ii) Quality efficiency (iii) Quality control (iv) Quality calculation20192m
Module 4: Software Testing
From the following, which quality deals with maintaining the quality of the software product?
(i) Quality assurance
(ii) Quality efficiency
(iii) Quality control
(iv) Quality calculation

View this question on its own page →
Search Google Ask AI
Worked Solution
Answer

(iii) Quality control

Explanation

Quality Control (QC) focuses on detecting defects and checking whether the developed product meets specified quality requirements. Quality Assurance (QA) is broader and focuses on preventing defects by improving processes.

Since the question asks which quality activity deals with maintaining the quality of the software product, the expected answer is Quality Control.

Final answer: (iii) Quality control
Q1i. Classes communicate with one another via: (i) processed information (ii) interfaces (iii) messages (iv) coupling20192m
Module 3: Software Design & Metrics
Classes communicate with one another via:
(i) processed information
(ii) interfaces
(iii) messages
(iv) coupling

View this question on its own page →
Search Google Ask AI
Worked Solution
Answer

(iii) Messages

Explanation

In object-oriented systems, objects/classes communicate by sending messages to request operations from one another. A message identifies an operation and may carry parameters.

Final answer: (iii) messages
Q1j. Software is not considered to be collection of executable programming code, associated libraries and documentations. (i) Statement is true (ii) Software is only data structures with algorithms (iii) Statement is false (iv) Statement underestimates software20192m
Module 1: Introduction & SDLC
Software is not considered to be collection of executable programming code, associated libraries and documentations.
(i) Statement is true
(ii) Software is only data structures with algorithms
(iii) Statement is false
(iv) Statement underestimates software

View this question on its own page →
Search Google Ask AI
Worked Solution
Answer

(iii) Statement is false

Explanation

Software is more than executable code. It includes programs, associated data/configuration, libraries or other supporting components, and documentation required for operation, maintenance and use.

Therefore the statement saying software is not considered such a collection is false.

Final answer: (iii) Statement is false

Q2. Write down the advantages of spiral model over basic waterfall model.201914m

Module 1: Introduction & SDLC

Write down the advantages of spiral model over basic waterfall model.

View this question on its own page →

Search Google Ask AI

Worked Solution

Advantages of the Spiral Model over the Basic Waterfall Model

The Spiral Model, proposed by Barry Boehm, is an iterative and risk-driven development model. Unlike the basic Waterfall Model, development proceeds through repeated cycles.

Major advantages

Risk analysis: Risks are identified and addressed explicitly in every spiral cycle.
Early customer feedback: Customers can review prototypes and intermediate versions early.
Handles changing requirements: Requirements can be refined as the project progresses.
Early prototyping: Prototypes can be developed to clarify uncertain requirements or technology.
Incremental development: The product grows through successive iterations rather than one final delivery.
Better visibility: Each cycle produces measurable work products and review points.
Suitable for large, complex projects: It is useful when technical or business risks are high.
Flexible: Changes can be incorporated without restarting the entire development process.
Continuous verification: Each iteration includes evaluation and review.

Spiral vs Waterfall

Waterfall	Spiral
Mostly sequential	Iterative
Risk analysis is not the central driver	Risk analysis is central
Changes are expensive after a phase is completed	Changes can be incorporated between iterations
Customer feedback is relatively late	Customer feedback occurs repeatedly
Best when requirements are stable	Useful when requirements/risks are uncertain

Conclusion: The spiral model provides greater flexibility and systematic risk management than the basic waterfall model, although it is more complex and can cost more to manage.

Q3. What do you mean by software cost estimation? Explain Boehm's COCOMO model in detail. Suppose an embedded project has 50 KLOC; calculate the development time of the software.201914m
Module 1: Introduction & SDLC
What do you mean by software cost estimation? Explain Boehm's COCOMO model in detail. Suppose an embedded project has 50 KLOC; calculate the development time of the software.

View this question on its own page →
Search Google Ask AI
Worked Solution
Software Cost Estimation and Boehm's COCOMO Model

1. Software cost estimation

Software cost estimation is the process of predicting the effort, development time and cost required to develop and maintain a software system.

It is usually based on factors such as:

Size of the software, often measured in KLOC (thousand lines of code).

Required reliability and complexity.

Team capability and experience.

Tools and technology.

Schedule and development environment.

2. Basic COCOMO

Boehm's COCOMO (Constructive Cost Model) estimates development effort and schedule from software size.

For the basic model:

Effort (person-months) = a × (KLOC)^b

Development Time (months) = c × (Effort)^d

The coefficients depend on the project mode.

Mode Effort equation Time equation

Organic 2.4 × KLOC^1.05 2.5 × Effort^0.38

Semi-detached 3.0 × KLOC^1.12 2.5 × Effort^0.35

Embedded 3.6 × KLOC^1.20 2.5 × Effort^0.32

3. Given problem

Embedded project = 50 KLOC

For an embedded project:

Effort = 3.6 × (50)^1.20

Effort ≈ 393.61 person-months

Now calculate development time:

Tdev = 2.5 × (393.61)^0.32

Tdev ≈ 16.92 months

Final result

Estimated effort ≈ 393.6 person-months

Estimated development time ≈ 16.9 months (about 17 months)

Exam note: This calculation uses the Basic COCOMO coefficients for the Embedded mode, which is the standard interpretation of the question.

Mode	Effort equation	Time equation
Organic	`2.4 × KLOC^1.05`	`2.5 × Effort^0.38`
Semi-detached	`3.0 × KLOC^1.12`	`2.5 × Effort^0.35`
Embedded	`3.6 × KLOC^1.20`	`2.5 × Effort^0.32`

Q4. Give four major types of software metrics using specific examples. Also, explain how object-oriented design metrics might be used to perform the quantitative assessment of software quality.201914m

Module 3: Software Design & Metrics

Give four major types of software metrics using specific examples. Also, explain how object-oriented design metrics might be used to perform the quantitative assessment of software quality.

View this question on its own page →

Search Google Ask AI

Worked Solution

Software Metrics and Object-Oriented Design Metrics

1. Major types of software metrics

Software metrics are quantitative measures used to understand and control software products, processes and projects. Four useful categories are:

Type	What it measures	Example
Product metrics	Characteristics of the software product	LOC, defect density, complexity
Process metrics	Effectiveness of the development/maintenance process	Defect removal efficiency, review effectiveness
Project metrics	Project progress and management	Effort, cost, schedule variance
Quality metrics	Quality attributes of the delivered software	Reliability, maintainability, usability, failure rate

2. Object-oriented design metrics

Object-oriented metrics quantify properties of classes, inheritance, coupling and cohesion. A well-known set is the CK (Chidamber–Kemerer) metric suite.

Important examples:

WMC — Weighted Methods per Class: measures the number/complexity of methods in a class.
DIT — Depth of Inheritance Tree: measures how deep a class is in the inheritance hierarchy.
NOC — Number of Children: counts immediate subclasses of a class.
CBO — Coupling Between Object classes: measures coupling between classes.
RFC — Response for a Class: counts methods that can potentially execute in response to a message to the class.
LCOM — Lack of Cohesion of Methods: indicates how unrelated the methods of a class are.

3. Quantitative assessment of quality

These metrics can be collected across versions and compared with thresholds or historical baselines.

For example:

High CBO may indicate excessive coupling and lower maintainability.
High LCOM may indicate poor class cohesion.
Very high WMC may indicate a class that is difficult to understand or test.
Large DIT can increase reuse but may also make behavior harder to understand.
High NOC can indicate significant reuse of a superclass, but changes to the superclass may affect many subclasses.

Thus, object-oriented design metrics turn design characteristics into measurable indicators that can support quantitative quality assessment and identify classes needing refactoring or review.

Q5. Software maintenance costs are influenced by a number of technical and non-technical factors. Some of the factors are—module independence, programming style, documentation, staff stability, hardware stability and software age. Which of the above factors can be controlled by software engineer while developing new software? For each of these controllable factors, explain how a software engineer would attempt to minimize future maintenance costs.201914m
Module 5: Software Maintenance
Software maintenance costs are influenced by a number of technical and non-technical factors. Some of the factors are—module independence, programming style, documentation, staff stability, hardware stability and software age. Which of the above factors can be controlled by software engineer while developing new software? For each of these controllable factors, explain how a software engineer would attempt to minimize future maintenance costs.

View this question on its own page →
Search Google Ask AI
Worked Solution
Controlling Future Software Maintenance Costs

The question lists six factors: module independence, programming style, documentation, staff stability, hardware stability and software age.

A software engineer can directly control or strongly influence the following during development:

1. Module independence

Design modules with high cohesion and low coupling.

How to reduce future cost:

Give each module a clear responsibility.

Minimize unnecessary dependencies.

Use well-defined interfaces.

Avoid shared global data where possible.

This localizes changes and reduces regression risk.

2. Programming style

Use consistent, readable and maintainable coding standards.

How to reduce future cost:

Follow naming and formatting conventions.

Use meaningful identifiers.

Avoid unnecessary complexity.

Apply code reviews and static analysis.

Keep functions/classes reasonably focused.

Readable code reduces the time needed to understand and modify the system.

3. Documentation

Maintain accurate technical and user documentation.

How to reduce future cost:

Document architecture and interfaces.

Explain important design decisions.

Keep API and configuration documentation current.

Document installation, operation and troubleshooting.

Good documentation reduces knowledge-transfer and maintenance effort.

Factors not directly controlled by the software engineer

Staff stability: strongly influenced by organizational management and retention policies.

Hardware stability: depends on hardware, infrastructure and external operational factors.

Software age: increases naturally as the system remains in use.

An engineer can design for portability and maintainability to reduce the impact of these factors, but cannot directly control them.

Conclusion: During development, the strongest direct levers are module independence, programming style and documentation.
Q6. It is believed that the quality of software is determined by the quality of its developers in terms of their knowledge, discipline and commitment. Explain the typical project manager's problem of people selection, motivation and team effectiveness in an IT department and discuss the extent to which the personal software process model can provide a solution.201914m
Module 1: Introduction & SDLC
It is believed that the quality of software is determined by the quality of its developers in terms of their knowledge, discipline and commitment. Explain the typical project manager's problem of people selection, motivation and team effectiveness in an IT department and discuss the extent to which the personal software process model can provide a solution.

View this question on its own page →
Search Google Ask AI
Worked Solution
People Selection, Motivation, Team Effectiveness and PSP

Software quality depends heavily on the people who develop it. A project manager must build a team with suitable skills, keep members motivated and make the team work effectively.

1. People selection

The manager should match people to roles based on:

Technical knowledge and experience.

Problem-solving ability.

Communication skills.

Ability to work in a team.

Reliability and discipline.

Interest in the project and willingness to learn.

Poor selection can lead to skill gaps, conflicts, delays and defects.

2. Motivation

Common motivators include:

Meaningful and challenging work.

Recognition and constructive feedback.

Opportunities for learning and career growth.

Appropriate responsibility and autonomy.

Fair rewards and working conditions.

Clear goals.

Managers should understand individual differences rather than assuming the same motivation works for everyone.

3. Team effectiveness

An effective IT team needs:

Clear roles and responsibilities.

Shared objectives.

Good communication.

Trust and cooperation.

Appropriate leadership.

Mechanisms for resolving conflicts.

Regular progress and quality reviews.

4. Personal Software Process (PSP)

The Personal Software Process is a disciplined process framework that helps individual developers measure and improve their own software work.

Typical PSP practices include:

Planning and size/effort estimation.

Recording actual time and defects.

Design and code reviews.

Defect prevention and removal.

Postmortem analysis to improve future estimates and practices.

How far can PSP provide a solution?

PSP can improve individual discipline, estimation, quality awareness and defect management. It gives developers quantitative feedback about their own performance and helps them improve their process.

However, PSP does not directly solve organizational problems such as selecting the right people, compensation, leadership, team conflict or company culture. Those require management practices. PSP is therefore a supporting solution, not a complete people-management solution.

Conclusion: Effective software teams require both sound people management and disciplined individual processes such as PSP.

Q7. Give the techniques and benefits of verification and validation activities during software development.201914m

Module 4: Software Testing

Give the techniques and benefits of verification and validation activities during software development.

View this question on its own page →

Search Google Ask AI

Worked Solution

Verification and Validation: Techniques and Benefits

Verification asks: "Are we building the product right?" It checks whether software work products conform to specified requirements and design.

Validation asks: "Are we building the right product?" It checks whether the final/intermediate product satisfies actual user needs and intended use.

Verification techniques

Reviews: Requirements, architecture and design are examined by peers.
Walkthroughs: The author leads a team through the work product to identify defects.
Inspections: Formal, systematic examination using defined roles and checklists.
Static analysis: Tools analyze source code without executing it.
Traceability analysis: Requirements are traced to design, implementation and tests.
Document checking: Specifications and design artifacts are checked for consistency and completeness.

Validation techniques

Unit testing: Individual components are tested.
Integration testing: Interacting components are tested together.
System testing: The complete system is tested against requirements.
Acceptance testing: The customer/user evaluates whether the system meets acceptance criteria.
Regression testing: Existing behavior is checked after changes.
Usability and operational evaluation: The product is assessed in realistic use conditions.

Verification vs Validation

Verification	Validation
Focuses on conformance to specifications	Focuses on fitness for intended use
Often uses reviews and static techniques	Relies heavily on execution and user-oriented testing
Finds defects early in work products	Confirms behavior of the developed product

Benefits

Detects defects early when they are cheaper to fix.
Reduces rework and maintenance cost.
Improves reliability and quality.
Confirms requirements are implemented correctly.
Reduces project risk.
Improves customer confidence.
Provides evidence that quality objectives are being met.

Conclusion: Effective V&V combines reviews, inspections, analysis and testing throughout development rather than waiting until the end.

Q8. What do you mean by structured software design? Design level-1 DFD for cash ATM machine and explain it.201914m

Module 3: Software Design & Metrics

What do you mean by structured software design? Design level-1 DFD for cash ATM machine and explain it.

View this question on its own page →

Search Google Ask AI

Worked Solution

Structured Software Design and Level-1 DFD for a Cash ATM

1. Structured software design

Structured design is a systematic approach to converting requirements into a hierarchy of modules with clearly defined responsibilities and interfaces.

It emphasizes:

Top-down decomposition.
Functional independence.
High cohesion within modules.
Low coupling between modules.
Clear module interfaces.
Use of tools such as Data Flow Diagrams (DFDs) and structure charts.

2. Level-1 DFD for a Cash ATM

A Level-1 DFD decomposes the ATM system into major processes.

                         ┌──────────────────┐
                         │      Customer     │
                         └────────┬─────────┘
                                  │ Card + PIN
                                  ▼
                    ┌──────────────────────────┐
                    │ 1.0 Authenticate User    │
                    └────────────┬─────────────┘
                                 │ Authentication request
                                 ▼
                         ┌───────────────┐
                         │ Bank Database │
                         └───────┬───────┘
                                 │ Account status
                                 ▼
                    ┌──────────────────────────┐
                    │ 2.0 Process Transaction   │◄── Transaction details
                    └───────┬──────────┬────────┘
                            │          │
                 balance/update       │ cash request
                            ▼          ▼
                    ┌────────────┐  ┌────────────────┐
                    │ 3.0 Update │  │ 4.0 Dispense   │
                    │   Account  │  │     Cash       │
                    └─────┬──────┘  └───────┬────────┘
                          │                  │
                          ▼                  ▼
                    ┌───────────────┐   ┌──────────┐
                    │ Bank Database │   │ Customer │
                    └───────────────┘   └──────────┘

Main processes

1.0 Authenticate User — accepts card and PIN and verifies the customer with the bank database.

2.0 Process Transaction — accepts transaction type such as withdrawal, balance inquiry or deposit and checks the account information.

3.0 Update Account — records the transaction and updates the account balance.

4.0 Dispense Cash — counts and dispenses the requested amount when a valid cash withdrawal is approved.

Data stores / external entities

Customer: supplies card, PIN and transaction request; receives cash/receipt/status.
Bank Database: stores account information and transaction data.
ATM: performs authentication, transaction processing and cash dispensing.

Conclusion: Structured design breaks the ATM system into manageable modules, while the Level-1 DFD shows the major data flows between the customer, ATM processes and bank database.

Q9. Write short notes on the following: (a) Software reuse (b) Capability maturity model (c) Functional and non-functional requirements (d) Software re-engineering2019?m
Module 5: Software Maintenance
Write short notes on the following:
(a) Software reuse
(b) Capability maturity model
(c) Functional and non-functional requirements
(d) Software re-engineering

View this question on its own page →
Search Google Ask AI
Worked Solution
Short Notes

(a) Software Reuse

Software reuse means using existing software assets—such as components, libraries, frameworks, designs or services—in a new system instead of developing everything from scratch.

Benefits

Reduces development time and cost.

Improves reliability when proven components are reused.

Promotes standardization.

Reduces duplicated effort.

Example

A developer may reuse an existing authentication library rather than implementing password hashing and session management from the beginning.

(b) Capability Maturity Model (CMM)

The Capability Maturity Model is a framework for assessing and improving the maturity of an organization's software development process.

Five maturity levels

Initial — process is ad hoc and unpredictable.

Repeatable — basic project-management practices are established.

Defined — processes are documented and standardized across the organization.

Managed — processes are measured and controlled quantitatively.

Optimizing — continuous process improvement is emphasized.

CMM helps organizations make their software processes more disciplined, measurable and predictable.

(c) Functional and Non-functional Requirements

Functional requirements

Describe what the system must do—its services, behaviors and responses.

Example: "The ATM shall allow a customer to withdraw cash after successful authentication."

Non-functional requirements

Describe how well the system must operate or constraints under which it must operate.

Examples: performance, security, reliability, usability and availability.

Functional Non-functional

Specifies system behavior/services Specifies qualities and constraints

Example: process a withdrawal Example: respond within 2 seconds

(d) Software Re-engineering

Software re-engineering is the systematic examination and transformation of an existing software system to improve its maintainability, structure, performance or technology while preserving useful functionality.

Typical activities

Inventory analysis: identify systems/components that need attention.

Document restructuring: improve missing or outdated documentation.

Reverse engineering: recover higher-level design/knowledge from existing code.

Code restructuring: improve source code structure without changing intended behavior.

Data restructuring: reorganize or migrate data.

Forward engineering: rebuild or modernize the system using recovered knowledge.

Benefits

Extends software life.

Reduces maintenance difficulty.

Preserves valuable business functionality.

Can be cheaper and less risky than replacing a mature system completely.

Functional	Non-functional
Specifies system behavior/services	Specifies qualities and constraints
Example: process a withdrawal	Example: respond within 2 seconds

Next year2020

Software Engineering

Answer

Explanation

Answer

Explanation

Answer

Explanation

Answer

Explanation

Answer

Explanation

Answer

Explanation

Answer

Explanation

Answer

Explanation

Answer

Explanation

Answer

Explanation

Advantages of the Spiral Model over the Basic Waterfall Model

Major advantages

Spiral vs Waterfall

Software Cost Estimation and Boehm's COCOMO Model

1. Software cost estimation

2. Basic COCOMO

3. Given problem

Final result

Software Metrics and Object-Oriented Design Metrics

1. Major types of software metrics

2. Object-oriented design metrics

3. Quantitative assessment of quality

Controlling Future Software Maintenance Costs

1. Module independence

2. Programming style

3. Documentation

Factors not directly controlled by the software engineer

People Selection, Motivation, Team Effectiveness and PSP

1. People selection

2. Motivation

3. Team effectiveness

4. Personal Software Process (PSP)

How far can PSP provide a solution?

Verification and Validation: Techniques and Benefits

Verification techniques

Validation techniques

Verification vs Validation

Benefits

Structured Software Design and Level-1 DFD for a Cash ATM

1. Structured software design

2. Level-1 DFD for a Cash ATM

Main processes

Data stores / external entities

Short Notes

(a) Software Reuse

Benefits

Example

(b) Capability Maturity Model (CMM)

Five maturity levels

(c) Functional and Non-functional Requirements

Functional requirements

Non-functional requirements

(d) Software Re-engineering

Typical activities

Benefits