Unit -1

Introduction to Software Engineering:

Software engineering is a systematic and disciplined approach to developing, maintaining,
and managing software. It involves using engineering principles and methods to create
software that is reliable, efficient, and high-quality. The goal of software engineering is to
produce software systems that meet user requirements, are cost-effective, and can be
maintained and evolved over time.

Importance of Software Engineering as a Discipline:

- Quality Assurance: Software engineering emphasizes the use of best practices and
rigorous testing to ensure that software meets its requirements and is free of defects and
vulnerabilities.

- Cost-Efficiency: By following established engineering practices and methodologies,

development costs can be controlled, and the cost of fixing defects after deployment can be
minimized.

- Scalability: Software engineering enables the development of scalable systems that can
grow to accommodate increasing user demands and evolving business needs.

- Reliability: Well-engineered software is more reliable, resulting in fewer crashes and

errors, which ultimately improves the user experience and builds trust.

- Maintainability: Proper software engineering practices lead to well-organized code and

comprehensive documentation, making it easier to maintain and update software systems as
they age.

Software Applications:
Software applications encompass a wide range of programs, including:
- Operating Systems: Manage hardware resources and provide an interface for other
software.
- Database Management Systems: Organize, retrieve, and manipulate data efficiently.
- Web Applications: Deliver services through web browsers.
- Mobile Apps: Designed for smartphones and tablets, providing various functionalities.
- Business Applications: Serve specific business needs such as accounting, customer
relationship management (CRM), and enterprise resource planning (ERP).

Software Crisis
The software crisis includes various issues and challenges in software development:
- Rapid Growth: The increasing demand for software has made it challenging to manage
development efforts effectively.
- Increasing Complexity: Modern software systems have become incredibly complex,
making it difficult to ensure their reliability and maintainability.
- Quality and Productivity: Striking a balance between software quality and productivity
has been a constant challenge.
- Cost Overruns: Many software projects exceed their budgets and schedules, leading to
financial and operational difficulties.

Software Processes & Characteristics:

Software processes define how software is developed and maintained. Key characteristics
include:
- Systematic Approach: Software processes provide a systematic and organized way to
create and maintain software, ensuring consistency.
- Iterative and Incremental: Many software processes are iterative, allowing for
continuous improvement and adaptation.
- Tailoring: Processes can be tailored to meet the specific needs of a project, taking into
account its unique characteristics.
- Communication: Effective communication among team members and stakeholders is
crucial to understanding and managing requirements.
- Risk Management: Software processes incorporate risk management to identify and
mitigate potential issues early in the development process.

Software Life Cycle Models:

Various software life cycle models guide the development process. Here are more details on
the ones you mentioned:

- Waterfall Model:
- It's a linear and sequential approach.
- Phases: Requirements, Design, Implementation, Testing, Deployment, Maintenance.
- Best suited for projects with stable and well-understood requirements.
- Minimal flexibility for changing requirements once a phase is completed.

- Prototype Model:
- Involves creating a working prototype of the software to gather feedback.
- Useful for projects with evolving or unclear requirements.
- The prototype helps in refining requirements and design.

- Evolutionary Model:
- Focuses on incremental development and improvement of the software.
- Allows for flexibility and adaptation to changing requirements.
- Well-suited for projects with evolving and complex needs.

- Spiral Model:
- An iterative and risk-driven approach.
- Emphasizes risk analysis and management at each iteration.
- Suitable for complex, high-risk projects where changes are expected during development.

Requirement Engineering:
- Requirement engineering encompasses the entire process of requirements management,
from elicitation and analysis to documentation and maintenance.
 - It involves stakeholders such as end-users, customers, and system analysts collaborating
to understand the purpose and scope of the software system.

Functional and Non-functional Requirements

- Functional Requirements:
- Describe specific functionalities the software must perform.
- Typically documented as use cases, user stories, or functional specifications.
- Example: "The system shall allow users to log in using a username and password."

- Non-functional Requirements:
- Address the quality attributes and constraints of the system.
- Include performance, security, availability, and usability requirements.
- Example: "The system should respond to user requests within 2 seconds."

- User Requirements:
- User requirements are often expressed in natural language and capture the high-level
objectives of the system from the user's perspective.
- They serve as the foundation for more detailed technical specifications.

System Requirements:
- System requirements are derived from user requirements and provide the technical
details needed to design and implement the system.
- They cover aspects such as hardware and software specifications, data models, and
system architecture.

Requirement Elicitation Techniques:

- FAST (Function Analysis System Technique):
- A visual modeling technique that represents functions, actions, and their relationships
using diagrams.
- It helps identify the core functions of the system and their interdependencies.

- QFD (Quality Function Deployment):

- A structured approach for translating customer requirements into specific engineering
characteristics.
- It helps prioritize features and ensure alignment with customer needs.

- Use Case Approach:

- Focuses on the interactions between users and the system through scenarios and use
cases.
- Use cases describe how users interact with the system to achieve specific goals.

Requirements Analysis using DFD (Data Flow Diagrams):

- DFDs are graphical tools that illustrate how data moves through a system.
- They show processes, data stores, data flow, and external entities, helping to understand
the data processing within the system.
Data Dictionaries & ER Diagrams:
- Data Dictionaries:
- Define data elements used in the system, including their names, descriptions, and
attributes.
- Ensure consistency and understanding of data used in the system.

- ER (Entity-Relationship) Diagrams:
- Used to model data entities, their attributes, and relationships between them.
- Helpful for designing the database schema and understanding the data structure of the
system.

Requirements Documentation:
- Requirements are documented in a Software Requirements Specification (SRS)
document.
- The SRS serves as a formal agreement between stakeholders and the development
team, providing a comprehensive view of what the software will entail.

Nature of SRS:
- The SRS is a legal and contractual document that outlines the scope, functions,
constraints, and specifications of the software.
- It is used to guide the design, development, testing, and validation of the software.

Characteristics & Organization of SRS:

- An SRS should be clear, concise, complete, consistent, and unambiguous.
- Typical sections of an SRS include:
- Introduction
- System overview
- Functional requirements
- Non-functional requirements
- User interfaces
- System architecture
- Appendices

Requirement Management:
- Requirement management involves the systematic handling of requirements throughout
the software development life cycle.
- It includes change control, versioning, and traceability to ensure that requirements
remain aligned with project goals and that changes are properly documented.

IEEE Standard for SRS:

- The IEEE Std 830-1998 provides guidelines for creating Software Requirements
Specifications (SRS).
- It defines a standard structure for SRS documents, including sections like the
introduction, functional and non-functional requirements, system features, and more, to
enhance clarity and consistency.