Requirements Engineering

SY-21

Table of Contents

  • Requirements Engineering Tasks

        • Inception

        • Elicitation

        • Elaboration

        • Negotiation

        • Specification

        • Validation

        • Requirements Management

  • Requirement Elicitation Techniques

        • Activities

        • Stakeholder Analysis

        • Interviews

        • Brainstorming Sessions

        • Interface Analysis

        • Quality Function Deployment

        • Prototyping

  • Software Requirements: Functional, Non- Functional

        • Functional Requirements

        • Non- Functional Requirements

  • Domain Engineering activities

  • Summary

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


Requirements Engineering Tasks

The process of collecting the software requirement from the client then understand, evaluate and document it is called as requirement engineering. Requirements engineering is a vast domain that primarily focuses on modelling, analysis, design, and construction. It is the process that defines, identifies, manages, and develops requirements in a software engineering design process. This process uses tools, methods, and principles to describe the system’s behavior and the constraints that come along with it. Requirements engineering is the most important part every business must follow, in order to develop and release a project, as it is the first step towards key planning and implementation.

Requirement engineering consists of seven different tasks as follow:

1. Inception:-

This is the first phase of the requirements analysis process. This phase gives an outline of how to get started on a project. Inception is a task where the requirement engineering asks a set of questions to establish a software process. In this task, it understands the problem and evaluates with the proper solution. It collaborates with the relationship between the customer and the developer. Effective communication is very important in this stage, as this phase is the foundation as to what has to be done further. The developer and customer decide the overall scope and the nature of the question.

The points covered in this section are

· Understanding what is the problem

· Relationship and Communication between developer and customer

· Nature of the solution.

2. Elicitation:-

This is the second step in the process of analysing needs. This section focuses on collecting needs from participants. One has to be careful at this stage, as needs are what determine the essential purpose of a project. Understanding the type of customer requirements is very important for a developer. In this process, mistakes can be made about, not using the right requirements or forgetting a part. The right people must participate in this phase. The requirements are difficult because the following problems occur in elicitation-

· Problem of Scope: The requirements provided contain unnecessary information, are not well defined, are not likely to be used, or not possible to implement.

· Problem of Understanding: Lack of a clear understanding between the developer and the customer when setting the required requirements. Sometimes a customer may not know what they are looking for or an engineer may not understand one requirement from another.

· Problem of Volatility: Changing requirements over time can create difficulties in leading a project. It can lead to loss and loss of resources and time.

3. Elaboration:-

This is the third phase of the requirements analysis process. In this task, the information taken from user during inception and elaboration and refined in elaboration. Expansion and continuous monitoring is also done. The main task is to develop a clean software model using functions, features of a software. This section engages in modelling activities and develops a prototype that describes in detail the features and challenges using the required tools and functions.

4. Negotiation :-

This section emphasizes dialogue and exchange discussions on what is needed and what needs to be eliminated. In the negotiation process, the software engineer decides how the project will be accomplished with limited business resources. Negotiations are between the developer and the customer and they are in the process of doing the project with limited business resources. Risks of all needs are considered and discussed in a way that both the customer and the engineer are satisfied with the reference to continuous use. This phase creates development assumptions and achieves the impact of demand on project costs and delivery time. Customers are asked to prioritize needs and make assumptions about potential conflicts and experiences.

The points covered in this section are:

· Delivery time

· Availability of Resources

· Scope of needs

· Cost of the project

· Development Estimations

5. Specification :-

In the specification phase, the needs engineer collects all the requirements and develops a performance model. The requirement engineer created the final work product for the project. This last effective product will be the basis for any tasks, features or barriers that need to be considered. In this exercise, formalize the required software requirements such as informative, functional, conduct and behavioural. The software specification document is sent to the customer in a language they will understand, in order to provide an overview and glimpse of the working model. Requirements are formalized in both graphical and textual formats.

Models used in this phase are:

· ER

· DFD

· FDD

· Data Dictionaries

6. Validation :-

This is the sixth step in the process of analysing needs. The product of the work is constructed as an outpouring of required engineering and achieved by the step of verification. This section focuses on errors and debugging. Official technical reviews from software developer, users, customer and other stakeholders help in the process of ensuring basic requirements.

In the verification phase, the developer scans the specified document and checks the following:

· All requirements are stated and met in the appropriate manner

· Errors debugged and corrected

· Product work is structured according to standards

Everyone in this team takes part in checking the specification by examining for any errors, missing information, or anything that has to be added or checking for any unrealistic and problematic errors. Some of the validation techniques are the following-

· Requirements reviews/inspections.

· Prototyping.

· Test-case generation.

· Automated consistency analysis.


7. Requirements Management :-

This is the final stage of the needs analysis process. Demand management is a set of tasks in which the entire team participates in the identification, management, monitoring and implementation of project implementation and efficiency requirements. At this stage, the team is responsible for managing any changes that may occur during the operation. New needs are emerging, and at this stage, responsibility must be taken to manage and prioritize its position in the project and how this new change will affect the entire system, as well as how to deal with and adapt to change. Based on this section, the performance model will be carefully analysed and ready for customer delivery. After completing the trace table is upgraded. Examples of a trace table are features, resources, dependencies, sub-systems and the requirement interface.


There are several techniques available for elicitation, however, the commonly used techniques are explained below:


Requirement Elicitation Techniques

It's all about getting the information from the participants. The success of an elicitation technique used depends on the maturity of the analyst, developers, users, and the customer involved. In other words, once a business analysis has been communicated with stakeholders to understand their needs, it can be defined as a request. It can also be described as a collection of needs. Determining needs can be done by contacting participants directly or by conducting specific research, testing. Tasks can be Planned, Unplanned, or both.

· Planned activities include workshops, assessments.

· Unplanned activities occur randomly. Prior notice is not required for such activities. For example, you go directly to a client site and start discussing requirements but there was no specific agenda published in advance.

The following activities are part of the request:

· Prepare for Elicitation: The purpose here is to understand the scope of the task of attracting, choosing the right strategies, and planning the right resources.

· Conduct Elicitation: The purpose here is to evaluate and identify information related to change.

· Confirm Elicitation Results: In this step, the information collected in the request session is checked for accuracy.

1. Stakeholder Analysis :-

Stakeholders can include team members, customers, or anyone affected by the project or can be a supplier. Stakeholder analysis was performed to identify participants who would be affected by the program.

2. Interviews :-

The purpose of the interview is to understand the client's expectations in the software. It is not possible to negotiate with all stakeholders and therefore party representatives are selected based on their abilities and loyalty.

Interviews may be open-ended or structured.

Benefits:

· Interactive discussion with stakeholders.

· The immediate follow-up to ensure the interviewer’s understanding.

· Encourage participation and build relationships by establishing rapport with the stakeholder.

3. Brainstorming Sessions :-

This technique is used to generate new ideas and find a solution for a specific issue. The members included for brainstorming can be domain experts, subject matter experts. Multiple ideas and information give you a repository of knowledge and you can choose from different ideas.

This session is generally conducted around the table discussion. All participants should be given an equal amount of time to express their ideas. Every idea is documented so that everyone can see it.Finally, a document is prepared which consists of the list of requirements and their priority if possible.

Benefits:

· Creative thinking is the result of the brainstorming session.

· Plenty of ideas in a short time.

· Promotes equal participation.

4. Interface Analysis :-

Interface analysis is used to review the system, people, and processes. This analysis is used to identify how the information is exchanged between the components. An Interface can be described as a connection between two components.

Benefits:

· Provide missed requirements.

· Determine regulations or interface standards.

· Uncover areas where it could be a risk for the project.

5. Quality Function Deployment :-

In this technique customer satisfaction is of prime concern, hence it emphasizes on the requirements which are valuable to the customer.

3 types of requirements are identified –

· Normal requirements –

In this the objective and goals of the proposed software are discussed with the customer. Example – normal requirements for a result management system may be entry of marks, calculation of results, etc.

· Expected requirements –

These requirements are so obvious that the customer need not explicitly state them. Example – protection from unauthorized access.

· Exciting requirements –

It includes features that are beyond customer’s expectations and prove to be very satisfying when present. Example – when unauthorized access is detected, it should backup and shutdown all processes.

6. Prototyping :-

Prototyping is used to identify missing or unspecified requirements. In this technique, frequent demos are given to the client by creating the prototypes so that client can get an idea of how the product will look like. Prototypes can be used to create a mock-up of sites, and describe the process using diagrams.

Benefits:

· Gives a visual representation of the product.

· Stakeholders can provide feedback early.

7. Use case :-

This process combines text and images to provide a better understanding of needs. Usage cases define 'what', of the system and not 'how'. Therefore, they only provide an active view of the system. The design features of the application case include three main elements - Actor, Application cases, application case drawing.

Actor -

An external agent who is outside the system but interacts with it in some way. A character is probably a person, a machine etc. It is represented as an image of a stick. The characters can be the main characters or the second characters.

· Primary Actor - It needs help in the system to achieve the goal.

· Secondary Actor - Character in which the program needs help.

Use cases -

· They describe the sequence of interactions between the players and the system. They capture (the characters) what they are doing (interacting) with the program. A complete set of usage cases specifies all possible ways to use the system.

Use case diagram -

· The application status diagram clearly represents what happens when the character interacts with the system. Captures the operating system feature.

o The image of the stick is used to represent the character.

o Oval is used to represent the use case.

o The line is used to represent the relationship between the character and the state of use.



Software Requirements: Functional, Non- Functional

Requirements analysis is a very important process that makes the success of a program or software project evaluated. Requirements are usually divided into two types: Functional and non-functional requirements.

Functional Requirements:

Functional requirements define the function that a system or part of a system should perform and should be written in separate forms. Operational requirements define system behavior as they are associated with system performance.

All of these functionalities need to be included in the program as part of the contract. This is displayed or expressed in the form of an input that must be given to the system, the work performed and the expected output. Operational requirements should be written in simple language, so that it is easily understood. They are basically the requirements specified by the user which one can see directly in the final product, as opposed to the non-functional requirements. The examples of functional requirements are authentication, business rules, audit tracking, certification requirements, transaction corrections, etc.

Non-Functional Requirements:

These are basically the quality constraints that the system must satisfy according to the project contract. Non-functional requirements are not related to the software's functional aspect. These requirements define the general characteristics, behaviour of the system, and features that affect the experience of the user. They can be the necessities that specify the criteria that can be used to decide the operation instead of specific behaviors of the system They are also called non-functional requirements. Basic non-functional requirements are - usability, reliability, security, storage, cost, flexibility, configuration, performance, legal or regulatory requirements, etc.

Domain Engineering activities

  • Domain engineering, the whole process of reusing domain information in the production of new software programs. It is a key concept in systematic software reuse and product line engineering. The main idea in the use of organized software is the domain. Most organizations operate only a few domains. Repeatedly build the same systems within a given domain for diversity to meet different customer needs. Instead of building a separate system for each new system from scratch, significant savings can be achieved by reusing components of previous systems in the domain to build new ones.

  • The process of identifying domains, commitments, and finding similarities and differences between domain-based programs is called domain analysis. This information is captured on models used in the domain usage phase to create artifacts such as reusable components, specific domain language, or application generators that can be used to build new domains.

MEMBERS:

Sanjyot Kotgire (17)

Saksham Sharma (12)

Sajjal Mehra (11)

Saad alvi (6)