Software Engineering

What is Coupling and Cohesion?

Coupling: Coupling refers to the degree of interdependence between software modules, with
high coupling indicating close connections and low coupling indicating independence.

Types of coupling:

Data Coupling: Modules communicate through data, independent of each other. Examples
include customer billing systems.

Stamp Coupling: Modules pass the complete data structure from one to another, involving
tramp data. This choice may be necessary due to efficiency factors.

Control Coupling: Modules communicate by passing control information. Can be bad if

parameters indicate completely different behavior, good if parameters allow factoring and reuse
of functionality.

External Coupling: Modules depend on other modules, external to the software or hardware.
Examples include protocol, external file, device format.

Common Coupling: Modules share shared data, leading to difficulties in reusing modules and
controlling data accesses.
Content Coupling: One module can modify the data of another module. This is the worst form
of coupling and should be avoided.

Temporal Coupling: Two modules depend on the timing or order of events. This can result in
design issues and difficulties in testing and maintenance.

Sequential Coupling: The output of one module is used as the input of another module,
creating a chain of dependencies.

Communicational Coupling: Two or more modules share a common communication

mechanism. This can lead to performance issues and difficulty in debugging.

Functional Coupling: Two modules depend on each other’s functionality. This can result in
tightly-coupled code.

Data-Structured Coupling: Two or more modules share a common data structure.

Interaction Coupling: This occurs due to methods of a class invoking methods of other classes.

Component Coupling: This refers to the interaction between two classes where a class has
variables of the other class.

Cohesion: Cohesion is the degree to which elements within a module work together for a single
purpose, with high cohesion indicating close relationships and low cohesion indicating looser
relationships.
Types of Cohesion:

Functional Cohesion: Every essential element for a computation is contained in the component.
It performs the task and functions.

Sequential Cohesion: An element outputs data that becomes the input for another element. It
occurs naturally in functional programming languages.

Communicational Cohesion: Two elements operate on the same input data or contribute
towards the same output data. Example: updating a database record and sending it to the
printer.

Procedural Cohesion: Elements ensure the order of execution. Actions are still weakly
connected and unlikely to be reusable.

Temporal Cohesion: Elements are related by their timing involved. Example: Initializing all parts
of the system.

Logical Cohesion: Elements are logically related but not functionally. Example: A component
reads inputs from tape, disk, and network.

Coincidental Cohesion: Elements are not related. Example: Printing next line and reverse the
characters of a string in a single component.

More Information:- https://www.geeksforgeeks.org/software-engineering-coupling-and-cohesion/?ref=lbp#what-is-coupling-and-cohesion

Functional & Non-Functional Requirements:

Functional Requirements: These are end user demands basic system facilities, including input,
operation, and output, incorporated into contract. These requirements directly impact final
product, unlike non-functional ones.

Non-Functional Requirements: Non-behavioral requirements, also known as quality

constraints, are the factors that a system must meet according to the project contract, with
their implementation varying between projects.

Differentiation:

Examples of Functional & Non-Functional Requirements:

Online Banking System

1. Functional Requirements:

• Users should be able to log in with their username and password.

• Users should be able to check their account balance.

• Users should receive notifications after making a transaction.

2. Non-functional Requirements:

• The system should respond to user actions in less than 2 seconds.

• All transactions must be encrypted and comply with industry security standards.

• The system should be able to handle 100 million users with minimal downtime.
More Information:- https://www.geeksforgeeks.org/functional-vs-non-functional-requirements/#examples-of-functional-and-nonfunctional-
requirements
Goals of Software Implementation:

• Access to Latest Technology: Software implementation allows companies to meet the latest
tech requirements by replacing old apps with new ones.

• Effective Process for Implementation: A well-defined process increases the chances of

delivering expected outcomes.

• Minimized Downtime: Sophisticated software installation and execution reduce software

failure and downtime, ensuring organizational operations are not affected.

• Efficiency and Productivity: Automation can eliminate processes, implement tasks, and
increase productivity.

• Competitive Advantage: Successful software adaptations can help businesses outperform

competitors by speeding up reactions, improving customer service, and increasing innovation.

• Adaptation to Change: Software implementation often involves change management,

promoting a climate based on constant process improvement and adaptability.

• Maximizing ROI: Well-executed software implementation can yield significant financial returns
through cost savings, increased revenue, or both.
More Information: https://www.geeksforgeeks.org/what-is-software-implementation/#why-is-software-implementation-important

Three types of Software Requirements Specification (SRS):

There are three types of SRS (Software Requirements Specifications) described below:

Functional Requirements: This document explains software system outcomes, functional

requirements, and their relationship with inputs and outputs, providing detailed descriptions of
data inputs, units, and valid input ranges.

Interface Requirements: This section provides a comprehensive explanation of software

interfaces, which refer to the communication methods between software programs and users,
including shared memory and data streams.

Performance Requirements: The performance requirements section of an SRS outlines the

system's performance characteristics, including static and dynamic constraints, ensuring clear
and concise specifications.

More Information: https://www.geeksforgeeks.org/software-requirement-specification-srs-format/#functional-requirements

Requirement Gathering:

Requirements gathering is a crucial phase in software development life cycle, ensuring accuracy
and completeness of requirements, which are essential for project success.

Processes of Requirements Gathering in Software Development:

There are 6 steps crucial for requirement gathering processes

• Step 1 :- Assigning Roles: Identify and engage with all relevant stakeholders to capture diverse
requirements.
• Step 2 :- Define Project Scope: Outline the project's objectives, boundaries, and limitations to
establish a common understanding.
• Step 3 :- Conducting Stakeholder Interviews: Schedule interviews with key stakeholders to
gather information about their needs, preferences, and expectations.
• Step 4 :- Documenting Requirements: Systematically document requirements, including
functional and non-functional requirements.
• Step 5 :- Verifying and Validating Requirements: Verify and validate requirements to ensure
alignment with stakeholders' intentions and to meet project goals.
• Step 6 :- Prioritizing Requirements: Prioritize requirements based on their importance to
project goals and constraints, creating a development roadmap.

More Information :- https://www.geeksforgeeks.org/requirements-gathering-introduction-processes-benefits-and-tools/

Requirement Analysing:

Software requirement analysis is a thorough examination and description of software

requirements to identify the necessary and genuine requirements for effective problem-solving.

1. Problem Recognition :
Requirement analysis aims to understand objectives, value, benefits, and quality to
identify essential business problem solutions.

2. Evaluation and Synthesis :

Evaluation and synthesis are crucial tasks in software requirements, including defining
functions, data objects, data flow, understanding system behavior, identifying
constraints, and defining system interfaces.

3. Modeling :
The functional and behavioral models of a system are established after gathering
information from various tasks using a domain model or conceptual model.

4. Specification :
The software requirement specification (SRS) which helps to specify the requirement
whether it is functional or non-functional should be developed.

5. Review :
After developing the SRS, it must be reviewed to check whether it can be improved or
not and must be refined to make it better and increase the quality.

More Information :- https://www.geeksforgeeks.org/activities-involved-in-software-requirement-analysis/

COCOMO Model :

Definition :- The COCOMO Model, proposed by Barry Boehm in 1981, is a well-documented

procedural cost estimate model for software projects, predicting parameters like size, effort,
cost, time, and quality.

There are six phases of COCOMO Model:

1. Planning and requirements: The initial phase involves defining the project's
scope, objectives, and constraints, and creating a project plan outlining schedule,
resources, and milestones.

2. System design: The high-level architecture phase involves creating the software
system's structure, including major components, their interactions, and data flow
between them.

3. Detailed design: The phase involves creating detailed specifications for each system
component, detailing data structures, algorithms, and interfaces, breaking down the
system design into detailed descriptions.

5. Module code and test: The process involves creating the source code for each module
or component, coding its functionalities, implementing algorithms, and developing
interfaces as per the detailed design.

6. Integration and test: This phase involves integrating individual modules into a
comprehensive system, ensuring they function as intended.
 7. Cost Constructive model: The Constructive Cost Model (COCOMO) is a widely used
method for estimating the cost and effort required for software development projects.

Importance of the COCOMO Model:

• Cost Estimation: Methodical approach for resource planning and project budgeting.
• Resource Management: Efficient resource allocation considering team experience, project
size, and complexity.
• Project Planning: Assists in developing practical plans with attainable objectives, due dates,
and benchmarks.
• Risk Management: Early identification and mitigation of potential hazards.
• Support for Decisions: Quantitative foundation for scope, priorities, and resource allocation
choices.
• Benchmarking: Comparing projects to industry standards.
• Resource Optimization: Maximizing resource use for increased productivity and cost
reduction.

More Information :- https://www.geeksforgeeks.org/software-engineering-cocomo-model/

Software Risk:

Different types of risks in Software Project Development

1. Schedule Risk : Schedule-related risks, including time and project delivery planning risks,
can negatively impact project development, delivery, and overall organization/company
economy if not managed properly. Some reasons for Schedule risks –

• Time is not estimated perfectly

• Improper resource allocation

• Tracking of resources like system, skill, staff etc

• Frequent project scope expansion

• Failure in function identification and its’ completion

2. Budget Risk: Budget-related risks, primarily due to overruns, require proper financial
management for project success. Mismanagement can lead to budget concerns and
potential project failure. Some reasons for Budget risks –

• Wrong/Improper budget estimation

• Unexpected Project Scope expansion

• Mismanagement in budget handling

• Cost overruns

• Improper tracking of Budget

3. Operational Risks : Operational risk refers to procedural risks that occur in daily project
activities due to improper process implementation or external operational risks. Some
reasons for Operational risks –

• Insufficient resources

• Conflict between tasks and employees

• Improper management of tasks

• No proper planning about project

• Less number of skilled people

• Lack of communication and cooperation

• Lack of clarity in roles and responsibilities

• Insufficient training
 4. Technical Risks : Technical risks are functional or performance risks primarily affecting
the functionality or performance of a product or software component. Some reasons for
Technical risks –

• Frequent changes in requirement

• Less use of future technologies

• Less number of skilled employee

• High complexity in implementation

• Improper integration of modules

5. Programmatic Risks : Programmatic risks are external, unavoidable risks that are outside
of the control of programs and come from outside sources.Some reasons for
Programmatic risks –

• Rapid development of market

• Running out of fund / Limited fund for project development

• Changes in Government rules/policy

• Loss of contracts due to any reason

More Information :- https://www.geeksforgeeks.org/different-types-of-risks-in-software-project-development/

Software Risk Management:

Definition: Risk Management is a systematic approach to identifying, assessing, and managing

potential threats to an organization's finances, capital, and operations.

The risk management process

Risk management is a sequence of steps that help a software team to understand, analyze, and
manage uncertainty. Risk management process consists of

• Risks Identification.

• Risk Assessment.
 • Risks Planning.

• Risk Monitoring

Risk Identification

Risk identification is a systematic process of identifying and assessing potential threats or

hazards that could negatively impact an organization, its operations, or its workforce.

Risk analysis

Risk analysis is a crucial process that assesses the potential impact and likelihood of identified
risks on an organization, determining their severity and determining effective management
strategies.

Risk Planning

Risk planning is a strategic approach to effectively manage and mitigate identified risks,
encompassing prevention, mitigation, and contingency measures to safeguard an organization's
objectives and assets.

Risk Monitoring

Risk monitoring is a continuous process of tracking and managing identified risks to assess their
status, effectiveness, and alignment with organizational objectives and adapt to new challenges.

Benefits of risk management

Here are some benefits of risk management:

• Helps protect against potential losses.

• Improves decision-making by considering risks.

• Reduces unexpected expenses.

• Ensures adherence to laws and regulations.

• Builds resilience against unexpected challenges.

• Safeguards company reputation.

Limitation of Risk Management

Here are Some Limitation of Risk Management

• Too much focus on risk can lead to missed opportunities.

 • Implementing risk management can be expensive.

• Risk models can be overly complex and hard to understand.

• Having risk controls might make people feel too safe.

• Relies on accurate human judgment and can be prone to mistakes.

• Some risks are hard to predict or quantify.

• Managing risks can take a lot of time and resources.

More Information :- https://www.geeksforgeeks.org/risk-management-software-engineering/

Waterfall Model:

The waterfall model is a popular and effective version of the System Development Life Cycle
(SDLC) for software engineering, ensuring a development phases start after completion of the
previous one.

Phases of Waterfall Model:

Requirement Phase: The first phase is the requirement phase. The requirement phase involves
collecting and documenting system requirements, which is crucial for the next phases. The
design phase focuses on preparing the blueprint for the software system, ensuring no problems
arise and finding solutions to requirements.

Implementation Phase: The implementation phase involves installing hardware, software, and
application programs, and implementing database design. This phase is the longest lasting in
the waterfall model.
Verification Phase: The verification phase evaluates the software's quality and effectiveness,
ensuring defects are detected and reducing the risk of software failure.

Maintenance Phase: The maintenance phase is the final phase, where problems are addressed
and the finished software is maintained.

Advantages of Waterfall Model

• This model is simple and easy to understand.

• This is very useful for small projects.

• This model is easy to manage.

• The end goal is determined early.

• Each phase of this model is well explained.

• It provides a structured way to do things.

• This is a base model, all the SDLC models that came after this were created keeping this
in mind, although they worked to remove its shortcomings.

• In this model, we can move to the next phase only after the first phase is successfully
completed so that there is no overlapping between the phases.

Disadvantages of Waterfall Model

• In this model, complete and accurate requirements are expected at the beginning of the
development process.

• Working software is not available for very long during the development life cycle.

• We cannot go back to the previous phase due to which it is very difficult to change the
requirements.

• Risk is not assessed in this, hence there is high risk and uncertainty in this model.

• In this the testing period comes very late.

• Due to its sequential nature this model is not realistic in today's world.

• This is not a good model for large and complex projects.

More Information:- https://www.geeksforgeeks.org/top-8-software-development-models-used-in-industry/#1-waterfall-model

V-Model:

Definition: The V-Model, also known as the Verification and Validation Model, is a disciplined
SDLC model used in software development, executing each process sequentially, starting after
the previous phase ends.

Phases of V-Model:

Requirement Analysis: The requirements analysis is the first phase of the development cycle,
where the product's requirements are analyzed based on the customer's needs. This phase
determines the next phases and includes acceptance tests.

System Design: The system design phase involves preparing a complete design of the system,
including hardware and technical components.

Architecture Design: Architectural design, also known as high level design (HLD), involves
designing the software's internal and external connections.

Module Design: Module design, also known as low level design (LLD), involves specifying the
internal design of all modules, ensuring they align with the system architecture. Unit tests are
also designed during this phase.

Coding: The coding phase involves coding the design and specification from the previous
phases.

Validation Phases of V-Model:

Unit Testing: Unit testing verifies the technical design.

Integration Testing: Integration testing ensures all modules work together.

System Testing: System testing checks the system's functionality, with a focus on performance
and regression testing.
Acceptance Testing: Acceptance testing, on the other hand, checks the system's compatibility
with other systems and non-functional issues like load time and performance in the user
environment.

Advantages of V-Model

• This is a simple and easy to use model.

• Planning, testing and designing tests can be done even before coding.

• This is a very disciplined model, in which phase by phase development and testing goes
on.

• Defects are detected in the initial stage itself.

• Small and medium scale developments can be easily completed using it.

Disadvantages of V-Model

• This model is not suitable for any complex projects.

• There remains both high risk and uncertainty.

• This is not a suitable model for an ongoing project.

• This model is not at all suitable for a project which is unclear and in which there are
changes in the requirement.
More Information:- https://www.geeksforgeeks.org/top-8-software-development-models-used-in-industry/#2-vmodel

Incremental Model:

Definition: The Incremental Model divides software development into multiple increments,
following the same phases, allowing complex projects to be developed in multiple modules or
builds.

Phases of Incremental Model:

• Communication: Face-to-face interaction with customers to collect mandatory requirements.

• Planning: Dividing requirements into multiple modules for planning.

• Modeling: Preparing and saving module designs in DDS (Design Document Specification).

• Construction: Implementing the module design in coding and testing the code.

• Deployment: Providing the module for customer use after testing.

• Development of next modules: Combining previous modules to create new functionality. This
process continues until complete modules are developed.

Advantages of Incremental Model

• Important modules/functions are developed first and then the rest are added in chunks.

• Working software is prepared quickly and early during the software development life
cycle (SDLC).

• This model is flexible and less expensive to change requirements and scope.

• The customer can respond to each module and provide feedback if any changes are
needed.

• Project progress can be measured.

• It is easier to test and debug during a short iteration.

• Errors are easy to identify.

Disadvantages of Incremental Model

• Management is a continuous activity that must be handled.

• Before the project can be dismantled and built incrementally,

• The complete requirements of the software should be clear.

• This requires good planning and designing.

• The total cost of this model is higher.

More Information:- https://www.geeksforgeeks.org/top-8-software-development-models-used-in-industry/#3-incremental-model

RAD Model:

Definition: The RAD model is a rapid application development approach, is a methodology

similar to the incremental or waterfall model, primarily used for small projects.

Phases of RAD Model:

• Business modeling: Designing a business model based on the flow of information and
distribution between business channels.

• Data modeling: Defines data objects required for the business using the prepared business
model.

• Process modeling: Converts data objects to establish the business information flow to achieve
specific business objectives.

• Application generation: Building software based on the output of the previous phases, using
automation tools.

• Testing and turnover: Testing prototypes or components and interfaces separately during
each iteration, reducing testing time in rapid application development.

Advantage of RAD Model

• It reduces the time taken in development.

• In this the components are reused.

• It is flexible and it is easy to make any changes in it.

• It is easy to transfer like scripts because high level abstraction and intermediate codes
are used in it.

• There are very few defects in it because it is a prototype by nature.

 • In this, productivity can be increased in less time with less people.

• It is cost effective.

• It is suitable for small projects.

Disadvantages of RAD Model

• In this we need highly skilled developers and designers.

• It is very difficult to manage.

• It is not suitable for project that are complex and takes long time.

• In this, feedback from the client is required for the development of each phase.

• Automated code generation is very expensive.

• This model is suitable only for component based and scalable systems.

More Information:- https://www.geeksforgeeks.org/top-8-software-development-models-used-in-industry/#4-rad-model

Iterative Model:

Definition: The Iterative model involves developing software with specific requirements,
reviewing it, and making necessary changes, repeating the process until the final product is
achieved.

Phases of Iterative Model:

• Requirement Gathering & Analysis: Collects customer's software requirements and analyzes
feasibility.

• Design: Prepares software design using diagrams.

• Implementation: Codifies software design using various programming languages.

• Testing: Identifies bugs and errors through performance, security, requirement, and stress
testing.

• Deployment: Delivers software to customer and uses in their work environment.

• Post-deployment review: Checks for errors or new requirements.

• Maintenance: Addresses customer feedback, solves problems, fixes errors, and updates
software.

Advantage of Iterative model

• Quick identification of bugs and errors.

• Quick preparation of software with specific specifications.

• Easier testing and debugging each iteration.

• Reliable user feedback and blueprints.

• Adaptable to changing needs.

• Additional development time and limited documentation time.

• Risk identification and resolution during iteration.

Disadvantage of Iterative model

• Not suitable for small projects due to frequent iterations.

• Requires more resources due to repeated iterations.

• Frequent changes required due to constant requirements.

• Increases project budget and completion time.

• Difficulty controlling entire software development process.

• Difficulty in predicting completion date.

More Information:- https://www.geeksforgeeks.org/top-8-software-development-models-used-in-industry/#5-iterative-model
Prototype Model:

Definition: The prototype model involves creating software application prototypes, which are
then used to develop the final product.

Phases of Prototype Model:

Requirement Gathering: • Gathering detailed requirements from customers.

• Defining major requirements in detail.

Building the Initial Prototype: • Displaying basic requirements and introducing a user interface.

Reviewing the Prototype: • Presenting the prototype to end users or customers.

• Collecting feedback to improve the system. Revising and

Improving the Prototype: • Adapting the prototype based on feedback.

• Creating a new prototype if customer dissatisfaction occurs.

Advantages of Prototype model

• Ideal for creating easy, human-machine interaction applications.

• Used when specific knowledge about input, processing, and output is lacking.

• Suitable for developers uncertain about algorithm's capability or adaptability to an

operating system.

• Disadvantages of Prototype model

• Customers favor small fixes over system rebuilding.

• Initial prototype version often shows compromises.

 • Developers may make quick compromises for quick implementation, forgetting their
inappropriateness.
More Information:- https://www.geeksforgeeks.org/top-8-software-development-models-used-in-industry/#7-prototype-model

Agile Model:

Definition: Agile model is a combination of iterative and incremental models, that is, it is made
up of iterative and incremental models.

Principles of Agile Model:

• Customer representative maintains contact with customers during software development.

• Iterations are reviewed and re-evaluated by stakeholders and customer representatives.

• Demo of working software is provided to understand customer requirements.

• Incremental versions of the software are delivered to the customer representative.

• Small development team size (5-9 people) is recommended for face-to-face communication.

• Agile model emphasizes quick software changes.

• Two programmers work together: one for coding and the other for review.

Advantages of Agile Model

• Enables error-free code with minimal mistakes.

• Quick project completion.

• Allows customer representatives to easily change requirements.

 • Provides a realistic approach to software development.

• Focuses on teamwork.

• Has few rules and minimal documentation.

• No need for planning.

• Easy to manage.

• Provides flexibility to developers.

Disadvantages of Agile Model

• Cannot handle complex dependencies.

• Lacks formal documentation leading to development confusion.

• Depends heavily on customer representatives.

• Only experienced programmers can make decisions.

• Initial effort and time required for software creation is unknown.

More Information:- https://www.geeksforgeeks.org/top-8-software-development-models-used-in-industry/#8-agile-model

Phase Containment of Errors:

Definition: Phase Containment of Errors is the practice of identifying and resolving defects early
in the Software Development Life Cycle (SDLC) to reduce costs and rework.