Software Engineering UNIT 1 &

2 - Short Notes by (
www.techbloop.com )

Visit for more information: Tech Bloop ( www.techbloop.com )

Table of Contents
UNIT - 1
Introduction
Introduction to Software Engineering:
Importance of Software Engineering as a Discipline:
Software Applications:
Software Crisis:
Software Processes & Characteristics:
Software Life Cycle Models:
Waterfall Model:
Prototype Model:
Evolutionary Model:
Spiral Model:
Software Requirements Analysis & Specifications
Requirement Engineering:
Functional and Non-Functional Requirements:
User Requirements and System Requirements:
Requirement Elicitation Techniques:
Requirements Analysis using DFD, Data Dictionaries & ER Diagrams:
Requirements Documentation:
Nature of SRS (Software Requirements Specification):
Characteristics & Organization of SRS:
Requirement Management:
IEEE Std. for SRS:
UNIT - 2

Software Engineering UNIT 1 & 2 - Short Notes by ( www.techbloop.com ) 1

 Software Project Planning
Size Estimation - Lines of Code & Function Count:
Cost Estimation Models:
COCOMO (Constructive Cost Model):
Putnam Resource Allocation Model:
Validating Software Estimates:
Risk Management:
Software Design
Cohesion & Coupling:
Classification of Cohesiveness:
Classification of Coupling:
Function-Oriented Design:
Object-Oriented Design:
User Interface Design:

UNIT - 1

Introduction

Introduction to Software Engineering:

Software Engineering is a systematic approach to software development.

It involves designing, coding, testing, and maintaining software.

Importance of Software Engineering as a Discipline:

Ensures cost-effective, timely, and reliable software development.

Minimizes risks and errors, leading to better software quality.

Promotes collaboration among team members.

Software Applications:
Categorized into system software, application software, and embedded software.

Software Engineering UNIT 1 & 2 - Short Notes by ( www.techbloop.com ) 2

 Used in fields like healthcare, finance, entertainment, etc.

Software Crisis:
Refers to challenges in software development like cost overruns and missed
deadlines.

Led to the need for structured software engineering practices.

Software Processes & Characteristics:

Software processes are sets of development activities.

Characteristics include repeatability, scalability, and predictability.

Software Life Cycle Models:

Waterfall, Prototype, Evolutionary, Spiral models.

Waterfall Model:
Sequential phases: requirements, design, implementation, testing, deployment,
and maintenance.

Each phase must be completed before moving to the next.

Suitable for projects with well-defined and stable requirements.

Prototype Model:
Develops a working prototype early for stakeholder feedback.

Useful when requirements are not well-understood or may change.

Evolutionary Model:
Iterative approach with cycles adding functionality and improvements.

Beneficial for complex and rapidly changing projects.

Spiral Model:
Combines elements of Waterfall and Evolutionary models.

Multiple cycles with planning, risk analysis, engineering, testing, and evaluation.

Suitable for large, high-risk projects with regular risk assessment.

Software Engineering UNIT 1 & 2 - Short Notes by ( www.techbloop.com ) 3

 Software Requirements Analysis & Specifications

Requirement Engineering:
Requirement engineering is the process of eliciting, analyzing, documenting, and
managing software requirements.

It is a critical phase to ensure that the software developed meets the needs and
expectations of the stakeholders.

Functional and Non-Functional Requirements:

Functional requirements specify what the software should do, its features, and
capabilities.

Non-functional requirements define quality attributes, like performance, security,

and usability.

User Requirements and System Requirements:

User requirements are high-level needs expressed by the end-users of the
software.

System requirements are detailed specifications derived from user requirements

and serve as a blueprint for development.

Requirement Elicitation Techniques:

FAST (Function Analysis System Technique) involves identifying and defining
functions the software must perform.

QFD (Quality Function Deployment) translates customer requirements into

specific product features.

Use case approach identifies system interactions through scenarios involving

actors.

Requirements Analysis using DFD, Data Dictionaries & ER

Diagrams:
Data Flow Diagrams (DFD) show how data flows through the system and how
it's processed.

Data dictionaries define data elements and their attributes in the system.

Software Engineering UNIT 1 & 2 - Short Notes by ( www.techbloop.com ) 4

 Entity-Relationship (ER) diagrams model data entities and their relationships.

Requirements Documentation:
Requirements must be documented to ensure clarity and manage changes.

Documentation includes use cases, flowcharts, data dictionaries, and other

artifacts.

Nature of SRS (Software Requirements Specification):

SRS is a formal document that describes the software's functional and non-
functional requirements.

It serves as a contract between stakeholders and development teams.

Characteristics & Organization of SRS:

SRS should be unambiguous, complete, consistent, and verifiable.

It typically includes an introduction, system overview, system features, external

interface, and more.

Requirement Management:
Requirement management involves tracking, prioritizing, and handling changes
to requirements.

It ensures that the software continues to meet stakeholder needs throughout the
project.

IEEE Std. for SRS:

The IEEE Std. 830-1998 is a widely used standard for Software Requirements
Specifications.

It provides a template and guidelines for creating SRS documents.

These notes cover the key aspects of software requirements analysis and
specifications. If you need further explanations, examples, or details on any specific
point, please feel free to ask.

Software Engineering UNIT 1 & 2 - Short Notes by ( www.techbloop.com ) 5

 UNIT - 2

Software Project Planning

Size Estimation - Lines of Code & Function Count:

Size estimation is the process of determining the size of the software to be
developed.

Two common size estimation metrics are:

Lines of Code (LOC): This measures the size of the software in terms of
lines of code to be written.

Function Count: Measures the size based on the number and complexity of
functions or modules.

Cost Estimation Models:

Cost estimation models predict the cost, effort, and time required for a software
project.

COCOMO (Constructive Cost Model):

COCOMO is a widely used cost estimation model.

It categorizes projects into three modes: Organic, Semi-Detached, and

Embedded.

Each mode uses a set of parameters to estimate the effort, cost, and duration.

Putnam Resource Allocation Model:

The Putnam model estimates project cost and duration based on resource
allocation.

It considers factors like team size, productivity, and the project's complexity.

Validating Software Estimates:

Software estimates should be validated and refined as the project progresses.

Software Engineering UNIT 1 & 2 - Short Notes by ( www.techbloop.com ) 6

 Historical data, expert judgment, and feedback from previous projects can help
in validation.

Risk Management:
Risk management is the process of identifying, assessing, and mitigating risks in
a software project.

Software Design

Cohesion & Coupling:

Cohesion refers to the degree to which the elements in a module are related to
one another.

Coupling refers to the degree of interdependence between modules in a

software system.

Classification of Cohesiveness:
Cohesion can be classified into several levels, including:

Functional Cohesion: All elements within a module are related to

performing a single function.

Sequential Cohesion: Elements are related in a sequence but not

necessarily a single function.

Communicational Cohesion: Elements perform multiple functions but

share data.

Procedural Cohesion: Elements are related due to a specific order of

execution.

Temporal Cohesion: Elements are related by when they are executed.

Logical Cohesion: Elements are related by logical grouping, but the

functions may be independent.

Classification of Coupling:
Coupling can be classified into various levels, including:

Software Engineering UNIT 1 & 2 - Short Notes by ( www.techbloop.com ) 7

 Content Coupling: One module accesses data or code inside another
module.

Common Coupling: Modules share global data.

Control Coupling: Modules share control information.

Stamp Coupling: Modules share a complex data structure.

Data Coupling: Modules share only data.

Message Coupling: Modules communicate through messages.

Function-Oriented Design:
Function-oriented design focuses on decomposing a system into smaller
functions or modules.

Each module is responsible for a specific function or subtask within the system.

Object-Oriented Design:
Object-oriented design organizes software around objects, which encapsulate
data and behavior.

It promotes reuse, modularity, and clear interactions between objects.

User Interface Design:

User Interface (UI) design involves creating a visually appealing and user-
friendly interface for the software.

It considers user interactions, aesthetics, and ease of use.

Tech Bloop: Navigating The Future ( www.techbloop.com ) 🚀

Software Engineering UNIT 1 & 2 - Short Notes by ( www.techbloop.com ) 8