SOFTWARE ENGINEERING

MODULE-1

1. Understanding Requirements.?
ANS. Requirements Engineering
Requirements engineering encompasses a broad spectrum of tasks and
techniques that lead to an understanding of requirements. It is a major software
engineering action that begins during communication and continues into
modeling. Requirements engineering tasks include:
 Inception
 Establish a basic understanding of the problem, stakeholders, desired
solution, and communication between stakeholders and the software
team.

 Elicitation
 Gather requirements by asking stakeholders about objectives, what needs
to be accomplished, how the system fits into business needs, and how it
will be used.
 Problems encountered include unclear scope, misunderstanding, and
requirement volatility.

 Elaboration
 Expand and refine requirements gathered during inception and elicitation.
 Develop a refined requirements model identifying software function,
behavior, and information.
 Create user scenarios describing end-user interactions with the system.

 Negotiation
 Reconcile conflicting requirements from different stakeholders by
prioritizing, assessing cost and risk, and addressing conflicts through an
iterative process.

 Specification
  Document requirements in various forms like written documents,
graphical models, formal models, usage scenarios, or prototypes.
 Use a consistent template for understandability, but remain flexible based
on project needs.

 Validation
 Validate requirements through reviews, prototyping, test case generation,
and consistency analysis to check for errors, missing information, and
feasibility.

 Management
 Manage changing requirements throughout development by identifying,
controlling, tracking, and prioritizing changes and their impact on the
system.
 Requirements engineering builds a bridge between communication,
modeling, design and construction. It ensures the final system meets
stakeholder needs and functions correctly.

2. , Establishing the ground work.?

ANS. Establishing the Groundwork
Establishing the groundwork for a software development project is essential for
its success. This phase involves key activities that set the stage for effective
planning, execution, and delivery. Below are the detailed steps involved in this
foundational stage:
1. Project Initiation
 Define Project Scope
Clearly articulate the objectives, deliverables, and boundaries of the project.
This includes understanding what the project will achieve and what is excluded
from its scope. A well-defined scope helps prevent scope creep and aligns
stakeholder expectations.
  Identify Stakeholders
Determine all individuals or groups who will be impacted by the project. This
includes customers, end-users, project sponsors, and team members.
Understanding stakeholder needs and expectations is crucial for project success.

 Conduct a Feasibility Study

Assess the technical, operational, and economic feasibility of the project. This
study helps identify potential challenges and ensures that the project is viable
before significant resources are committed.
2. Project Planning
 Develop a Project Plan
Create a comprehensive plan that outlines tasks, timelines, resources, and
milestones. This plan serves as a roadmap for the project and helps keep the
team on track. It should include a schedule, budget estimates, and resource
allocation.

 Establish Policies and Procedures

Define the guidelines and standards that will govern the project. This includes
communication protocols, quality assurance measures, and risk management
strategies. Clear policies help streamline processes and ensure consistency.
3. Team Formation
 Assemble the Project Team
Recruit team members with the necessary skills and expertise. Ensure that the
team is diverse and capable of addressing various aspects of the project, from
development to testing and deployment.

 Conduct Team-Building Activities

Foster a collaborative environment through team-building exercises. This helps
build trust and improves communication among team members, which is vital
for effective collaboration throughout the project.
4. Risk Management
 Develop a Risk Management Plan
Identify potential risks that could impact the project and develop strategies to
mitigate them. This proactive approach helps minimize disruptions and ensures
that the team is prepared to handle challenges as they arise.
5. Communication and Monitoring
 Manage Stakeholder Expectations
Establish a communication plan to keep stakeholders informed about project
progress. Regular updates and feedback loops help ensure that stakeholders
remain engaged and that their needs are being addressed.

 Monitor Project Progress

Continuously track the project's progress against the established plan. Use key
performance indicators (KPIs) to measure success and make adjustments as
necessary to stay on schedule and within budget.

3.Eliciting requirements.?
ANS. Eliciting Requirements
Eliciting requirements is a crucial process in software development that focuses
on gathering and understanding the needs and expectations of stakeholders.
Here’s a concise overview of the key aspects:
Importance of Eliciting Requirements
 Prevents Misunderstandings: Clear communication reduces the
risk of misinterpretation, leading to a more accurate understanding of user
needs.
 Enhances Project Success: Well-defined requirements ensure the
final product aligns with user expectations and business goals.
 Reduces Costs: Identifying requirements early minimizes the
likelihood of costly changes and rework later in the development process.
Techniques
 Interviews: Conduct one-on-one or group discussions with
stakeholders to gather detailed insights.
 Workshops: Facilitate collaborative meetings with multiple
stakeholders to discuss and prioritize requirements.
  Prototyping: Create mock-ups or prototypes to visualize requirements
and gather feedback.
 Surveys: Use structured surveys to collect quantitative data on user
needs and preferences.
 Observation: Observe users in their environment to identify
workflows and pain points.
 Use Cases: Develop use cases or user stories to clarify functionality and
user interactions.
Challenges
 Difficulty in establishing clear boundaries for the project.
 Different stakeholders may have opposing requirements, complicating
consensus.

3. Developing use cases.?

ANS. Developing Use Cases
Use cases are a powerful tool for capturing system requirements and modeling
interactions between users and a system. Here's a concise overview of the key
steps involved in developing use cases:
1. Identify Actors
 Determine the different types of users who will interact with the system
 Define each actor's goals and responsibilities
2. Identify Use Cases
 Determine the main functions the system must perform to meet user goals
 Organize use cases based on actor goals and system functionality
3. Describe Use Case Flows
 Define the basic flow of events for each use case
 Identify alternate flows and exceptional scenarios
4. Specify Use Case Details
 Describe preconditions, postconditions, and business rules
 Identify information inputs and outputs for each use case
5. Validate Use Cases
 Review use cases with stakeholders to ensure completeness and accuracy
 Identify and resolve conflicts or ambiguities
6. Organize Use Cases
 Group related use cases into packages or subsystems
 Establish relationships between use cases, such as include or extend
EXAMPLE.
4.Building a requrements model.?
ANS. Building a requirements model involves several key elements that help
define what a software system must accomplish. Below is a concise overview of
the primary components of a requirements model, along with an example.

 Components of a Requirements Model

 Scenario-Based Modeling: This approach captures the system's
functionality from the user's perspective through use cases. For instance,
in an airline application, a use case could describe a traveler generating a
boarding pass by entering their details.
 Class-Based Modeling: This element identifies classes, attributes,
and relationships within the system. In the airline example, the "Traveler"
class might include attributes such as name and passport number, while
the "Boarding Pass" class would contain details like flight number and
seat assignment.
 Data Modeling: This focuses on how data is structured and stored. It
translates the classes and their attributes into a database schema. For the
airline application, this would involve defining tables for travelers and
boarding passes.
 Flow-Oriented Modeling: This aspect illustrates how data flows
through the system, detailing the transformation of inputs into outputs. In
the airline application, it would show how user input (e.g., form
submission) leads to the generation of a boarding pass.
 Behavioral Modeling: This captures how the system behaves in
response to external events. For instance, a state diagram could represent
the various states of the boarding pass (e.g., generated, printed, canceled)
based on user actions.

Example
Consider a flight booking system:
Scenario-Based: A user searches for flights, selects one, and books a ticket.
Class-Based: Classes might include "User," "Flight," and "Booking," with
attributes like user ID, flight number, and booking status.
Data Modeling: The database schema would define tables for users, flights,
and bookings, detailing how they relate.
Flow-Oriented: The process flow might show the transition from user input
(search criteria) to output (displaying available flights).
Behavioral: A state diagram could illustrate the booking process, showing
states such as "Searching," "Booking," and "Confirmed."
 4. Negotiating Requirements, Validating Requirements in detail.?
ANS. Negotiating and validating requirements are critical processes in software
development that ensure the final product meets stakeholders' needs and
expectations. Below is a detailed yet concise overview of these two aspects.
1. Negotiating Requirements

 Negotiating requirements involves discussions among stakeholders to

reconcile differing needs and expectations. The process aims to achieve a
"win-win" outcome, balancing functionality, performance, and
constraints like cost and time-to-market. Key steps in this process
include:
 Identifying Stakeholders: Recognizing all parties involved in the
project, such as clients, users, and developers, to understand their
perspectives and interests.
 Establishing Win Conditions: Determining what each stakeholder
considers a successful outcome, which may include specific
functionalities, performance metrics, or budget constraints.
 Reconciling Conflicts: Engaging in negotiations to align the win
conditions of various stakeholders, ensuring that the final requirements
reflect a consensus that satisfies the majority.
Effective negotiation is essential to avoid conflicts that could derail the project
and to foster collaboration among stakeholders, ultimately leading to a more
robust requirements model.
2. Validating Requirements
Validating requirements is the process of ensuring that the documented
requirements are complete, consistent, and aligned with stakeholders' needs.
This involves several critical activities:
 Consistency Check: Reviewing the requirements for contradictions
and ensuring they align with the overall system objectives.
 Clarity and Necessity: Ensuring each requirement is well-defined,
unambiguous, and truly necessary for the system's goals, distinguishing
between essential features and optional enhancements.
 Testability: Confirming that each requirement can be tested once
implemented, allowing for verification that the system meets the specified
needs.
  Stakeholder Agreement: Ensuring all stakeholders concur with the
documented requirements and that any conflicts have been resolved,
which is crucial for project acceptance.
The validation process helps identify errors early, reducing the risk of costly
revisions later in the development cycle and ensuring that the requirements
accurately represent the desired functionality and behavior of the system

5. Requirements Modeling Scenarios and Information and Analysis classes?

ANS. Requirements modeling scenarios and information analysis classes are
integral components of the software development process, helping to define
system functionalities and data structures.
Requirements Modeling Scenarios
Requirements modeling scenarios provide a narrative framework that illustrates
how users interact with a system to achieve specific goals. These scenarios
capture the context of use, detailing the various tasks users perform, the
sequence of actions taken, and the expected outcomes. For example, in a flight
booking system, a scenario might describe a user searching for flights, selecting
a preferred option, entering passenger details, and completing the payment
process. This approach emphasizes user needs and helps identify essential
functionalities, ensuring that the system aligns with real-world usage.
Information and Analysis Classes
Information and analysis classes represent the data structures and relationships
within the system. These classes define the key entities, their attributes, and the
interactions between them. In the flight booking system, classes might include
"Flight," "Passenger," and "Booking," each with specific attributes such as
flight number, passenger name, and booking status. By organizing data into
classes, developers can create a clear schema that facilitates data management
and retrieval, ensuring that the system can effectively handle user requests and
maintain data integrity.

6. Requirement Analysis and Scenario based modeling?

ANS. Requirements Analysis
Requirements analysis is a critical phase in the software development lifecycle
that focuses on identifying, documenting, and managing the needs and
constraints of stakeholders involved in a project. Key activities include:
Stakeholder Identification: Recognizing all parties affected by the system,
including clients, end-users, and management.
Requirement Elicitation: Gathering requirements through interviews,
surveys, workshops, and other techniques to understand user needs and
expectations.
Requirement Specification: Clearly documenting requirements to ensure
they are measurable, realistic, and verifiable. This documentation serves as a
foundation for design and testing phases.
Prioritization: Assessing and ranking requirements based on their importance
and feasibility to manage scope effectively.
Validation: Ensuring that all documented requirements meet stakeholder
needs and are feasible to implement, often through reviews and feedback
sessions.
Scenario based modelling

Scenario-based modeling is a technique used to represent and explain concepts

in a diagrammatic way. It involves the use of modeling languages to create
scenarios that describe the interactions between actors (people or systems) and
the system being modeled. The purpose of scenario-based modeling is to define
what exists outside the system and what should be performed by the system.
 Scenario-based modeling uses use case diagrams and activity diagrams
to represent scenarios.
 Actors represent the roles that people or devices play in the system's
functions.
 Requirements modeling with UML begins with the creation of scenarios
in the form of use case diagrams and activity diagrams.
 An example of a use case diagram is provided for a food counter
scenario, which includes four actors: customer, expert menu system,
cook, and payment system.
 The use cases describe the actions performed by each actor, such as
making an automated menu selection, ordering food and drink, preparing
food, notifying the customer, and making a payment through the payment
system.
 7. UML models that supplement the Use Case.?
ANS. To supplement use case diagrams in UML, several models can enhance
understanding and clarity of system interactions and workflows. Here are key
UML models that serve this purpose:
Activity Diagrams: Activity diagrams illustrate the flow of control or data
within a system, making them particularly useful for modeling complex
processes and workflows. They show the sequence of activities, decisions, and
parallel processes involved in a use case, which helps visualize the overall
process. For example, in an online purchasing system, an activity diagram might
depict the steps involved in placing an order, including selecting items,
confirming the order, and processing payment.
Swimlane Diagrams: Swimlane diagrams are a specialized form of activity
diagrams that organize activities into lanes, each representing a different actor
or system component. They clarify roles and responsibilities by showing which
actor is responsible for each task in the process. Each lane corresponds to an
actor or system, and activities are placed in the appropriate lane to indicate who
performs them. In a food ordering system, a swimlane diagram could show the
customer, cook, and payment system in separate lanes, illustrating how they
interact during the order process.
Sequence Diagrams: Sequence diagrams focus on the order of message
exchanges between objects over time, providing a dynamic view of interactions.
They detail how objects communicate to fulfill a particular use case,
emphasizing the timing and order of messages. Sequence diagrams consist of
vertical lines representing objects and horizontal arrows indicating messages
exchanged between them. For a food ordering use case, a sequence diagram
might illustrate the flow of messages from the customer to the expert menu
system, then to the cook, and finally back to the customer with notifications.
State Diagrams: State diagrams model the various states an object can be in
and the transitions between those states based on events. They are useful for
understanding the lifecycle of an object and how it responds to different events,
which can be critical for systems with complex state-dependent behavior. State
diagrams include states, transitions, events, and actions that occur during state
changes. In a food ordering system, a state diagram could represent the states of
an order, such as Pending, In Preparation, Completed, and Delivered, along with
the events that trigger transitions between these states.