Syllabus

What is Software Engineering?

Software Engineering is the process of designing, developing,

testing, and maintaining software. It is a systematic and disciplined
approach to software development that aims to create high-quality,
reliable, and maintainable software.
Software engineering includes a variety of techniques, tools, and
methodologies, including requirements analysis, design, testing, and
maintenance.
It is a rapidly evolving field, and new tools and technologies are
constantly being developed to improve the software development
process.
By following the principles of software engineering and using the
appropriate tools and methodologies, software developers can create
high-quality, reliable, and maintainable software that meets the needs
of its users.
Software Engineering is mainly used for large projects based on
software systems rather than single programs or applications.
The main goal of Software Engineering is to develop software
applications for improving quality, budget, and time efficiency.
Software Engineering ensures that the software that has to be built
should be consistent, correct, also on budget, on time, and within the
required requirements.
❖ Principles of Software Engineering
1. Modularity: Breaking the software into smaller, reusable
components that can be developed and tested independently.

2. Abstraction: Hiding the implementation details of a component

and exposing only the necessary functionality to other parts of the
software.

3. Encapsulation: Wrapping up the data and functions of an object

into a single unit, and protecting the internal state of an object
from external modifications.

4. Reusability: Creating components that can be used in multiple

projects, which can save time and resources.

5. Maintenance: Regularly updating and improving the software

to fix bugs, add new features, and address security vulnerabilities.

6. Testing: Verifying that the software meets its requirements and

is free of bugs.

7. Design Patterns: Solving recurring problems in software design

by providing templates for solving them.

8. Agile methodologies: Using iterative and incremental

development processes that focus on customer satisfaction, rapid
delivery, and flexibility.

9. Continuous Integration & Deployment: Continuously

integrating the code changes and deploying them into the
production environment.
❖ Importance of Software Engineering

The importance of Software engineering is as follows:

1. Reduces complexity: Big software is always complicated and

challenging to progress. Software engineering has a great solution
to reduce the complication of any project. Software engineering
divides big problems into various small issues. And then start
solving each small issue one by one. All these small problems are
solved independently to each other.

2. To minimize software cost: Software needs a lot of hardwork

and software engineers are highly paid experts. A lot of manpower
is required to develop software with a large number of codes. But
in software engineering, programmers project everything and
decrease all those things that are not needed. In turn, the cost for
software productions becomes less as compared to any software
that does not use software engineering methods.
3. To decrease time: Anything that is not made according to the
project always wastes time. And if you are making great software,
then you may need to run many codes to get the definitive running
code. This is a very time-consuming procedure, and if it is not well
handled, then this can take a lot of time. So if you are making your
software according to the software engineering method, then it
will decrease a lot of time.

4. Handling big projects: Big projects are not done in a couple of

days, and they need lots of patience, planning, and management.
And to invest six and seven months in any company, it requires
heaps of planning, direction, testing, and maintenance. No one
can say that he has given four months of a company to the task,
and the project is still in its first stage. Because the company has
provided many resources to the plan and it should be completed.
So to handle a big project without any problem, the company has
to go for a software engineering method.

5. Reliable software: Software should be secure, meaning if you

have delivered the software, then it should work for at least its
given time or subscription. And if any bugs come in the software,
the company is responsible for solving all these bugs. Because in
software engineering, testing and maintenance are given, so there
is no worry of its reliability.

6. Effectiveness: Effectiveness comes if anything has been made

according to the standards. Software standards are the big target
of companies to make it more effective. So Software becomes more
effective in the act with the help of software engineering.
 ❖ Difference between Software Engineering
and Software Programming :

Software engineering involves designing and planning software, while

software programming involves writing code to implement that design.
Software engineers are more involved in the entire software
development process, while programmers focus on specific aspects.
- Software engineering
1. Design
Software engineers design the blueprints for software
frameworks.
2. Development
Software engineers are involved in the entire development
process, from conception to release.
3. Planning
Software engineers plan and design at a high level, considering
the bigger picture.
 4. Process
Software engineers follow a systematic process to understand
requirements and develop solutions.
5. Goal
Software engineers aim to develop high-quality software
products on time and within budget.

- Software programming
1. Code: Software programmers write code to implement the
designs created by software engineers.

2. Development: Software programmers work on specific aspects

of the development process.

3. Skills: Software programmers are coding specialists who use

coding languages to construct software.

❖ Members involved in Software

Development:
Software development involves multiple roles to ensure the successful
creation, testing, deployment, and maintenance of software. The key
members involved include:

1. Project Manager (PM):

Responsible for planning, organizing, and overseeing the project. They
ensure that timelines, budgets, and deliverables are met.
The project manager is accountable for knowing the “who, what, where,
when, and why of the software plan. A Project Manager in a
software development team often deals with various crucial roles
and responsibilities including:
● Making a software plan.
● Developing a schedule.
● Planning a budget.
● Executing it in a proper manner.
● Lastly, develop the project.

2. Product Owner
Product owner refers to an individual who has the knowledge of how a
terminal product or the outcome should look like. They have an
enormous idea about the project and its users. Moreover, they
understand the client’s requirements, therefore they are in the
predominant position to lead the development towards an adequate
terminal product.

3. Business Analyst
A business analyst is accountable for comprehending business needs
into requirements and making sure they are documented perfectly
before a compound is formed and implemented. They describe, analyze
and control technology and business needs throughout the cycle. They
accompany the consumer so that they don’t have any doubt about the
project. They make decisions and carry out meetings of the project’s
methodology. Some tools which are used by Business Analysts are Jira
and Confluence, Pencil, Google Doc, Trello, Balsamiq, etc.
4. Software Developers
They are responsible for utilizing the technical requirements from the
technical leads to form cost and deadline estimates. They write code
and evolve the software products. Developers are the actual members
who write code to make the software function.
The team members have to communicate the technical requirements to
the developers to reduce project risk, give ideas, and achieve great
success. Some of the tools which are used by software developers
(backend) are Eclipse, VS Code, Postman, Jenkins, Github, Stack
Overflow, Jira, Chrome DevTools, Docker, and other programming
frameworks and tools as well.

6. UI Designer
The utmost duty of the UI designer is to prepare or design the user
affiliate. They transfer content, graphics, and style affixes with a client.
They prepare templates using prototyping tools. With a UX designer
and front-end developers, they work on providing solutions to meet
expectations and needs. Some tools which are used by UI Designer are
Adobe XD, Axure, Figma, Sketch, Visual Studio Code, etc.

7. UX Designer
UX designer means user experience. It is characterized by a less
‘digital’ perspective to a user affix. They have to assure that the end-user
has the best experience while working on the application. They have to
be in contact with the continuous human-computer interaction method.
Some tools which are used by UX Designer are Sketch, InVision Studio,
Craft, Adobe XD, Axure, etc.
6. Quality Assurance (QA) Engineers/Testers:
Test the software for bugs and ensure it meets the quality standards
through manual and automated testing
A QA person is liable for making equipment that allows automating
processes that identify and verify the software quality. They shorten
stability verification time. They check if the work on new features didn’t
cause errors in the already existing and functioning system. Some tools
which are used by QA engineers are Jira, Jenkins, Selenium, Cucumber,
Postman, LambdaTest, Test Flight, Confluence, and many others. .
Testers are in-charge of ensuring the software solution meets the
demands and complies with the qualities level. They need to understand
feature requirements. Also, they form and execute test cases to detect
bugs or deficiencies. Some of the tools which are used by software
testers are Selenium, TestingWhiz, TestComplete, Katalon Studio,
Postman, Jira, Apache JMeter, etc.

7. DevOps Engineers:
Manage the software's infrastructure, deployment, and continuous
integration/continuous delivery (CI/CD) pipelines.

8. Database Administrators (DBAs):

Design, implement, and manage databases to store and retrieve
application data efficiently.

9. System Architect:
Designs the software system's overall structure and ensures scalability,
performance, and security.
10. Technical Writers:
Create documentation, user manuals, and help guides for the software.
11. Scrum Master (in Agile Teams):
Facilitates Agile processes, removes obstacles, and ensures the team
follows Agile practices.

12. Security Specialists:

Ensure the software is secure by identifying and mitigating
vulnerabilities.

13. Support and Maintenance Team:

Handles post-deployment support, resolves user issues, and maintains
the software.

Each member plays a critical role in delivering high-quality software.

The size and composition of the team may vary based on the project's
scope and complexity.

❖ Why do we Need Software Engineering?

Most people don't give a second thought to new technologies as

they make their life easier and more comfortable to drive. We need
software engineering because software engineering is important
in daily life. We have technology like Alexa only because we have
software engineering. It has made things possible which are
always beyond our imagination. Let's explore some points to
answer why we need software engineering:

1. The rise of technology

The rise of technology has catapulted software engineering to the
leading edge of the enterprise world and made it pretty critical. As
technology continues to seep into each component of our lives, we can
need software program improvement more, and it will become even
more vital. From working manually and on an analog basis, engineers
have automated every aspect of life by nurturing software development
as an industry.

2. Adding structure
Without software engineering, we have people who can code. But
software engineering methodology has a structure to everything
and makes the lifecycle and business process easy and reliable.

3. Preventing issues
The software development process has now been formalized to
prevent the software project from running over budget,
mismanagement, and poor planning. The process of quality
assurance and user testing is vital as it helps prevent future
issues at lower costs. And this is only possible due to software
engineering. For the success of projects, it becomes vitally
important.

4. Huge Programming
Huge programming is possible because of software engineering as
it becomes the extensive one that has steps to give them a scientific
process.

5. Automation & AI
Currently, Automation and AI are hot subjects in the IT industry.
Because of software development, the manufacturing industry is
overhauled by automation. The quantity of humans operating on
manufacturing unit flooring continues to decrease as automation
software improves. As this fashion continues, maximum
engineering disciplines will probably rely upon software
improvement in a few ways.

6. Research
Through research and development, only new technology arises
from the industry. It is possible today because software
engineering is at the forefront of new technology research and
development. Through each step forward, other parts of the
industry can flourish as we stand on the shoulders of giants.

❖ Benefits of Software Engineer

Software engineering has structured the code world and allowed
generations to increase. We ought to also understand the
benefits of software program engineering:

1. Best Practices
It provided us with the best practices being the consent of
software engineering. To gain experience, some practices include
KISS, Testing code, Refactoring code, Version control,
readability, etc. But the best practice is that which delivers
simple code with effective work.

2. Maintainability
With the maintainability of codebases, software engineering has
become mature. The maintenance is all about corrections and
modifications to drive smoothly.
3. Scalability
Scalability is everything in the world of web development and
SaaS products. And such products are built to work under
varying loads only because software engineering has made it so.

4. Accessibility and Usability

Now accessibility is more important than ever. The internet
wouldn't be accessible today to many disabled people without the
help of software engineers. Their work has been crucial in
ensuring that the internet is open to everyone.

5. Security
Software engineering has become more significant than at any
other time since individuals can get to your applications from
any device and area. It implies many moving parts and
developing a security strategy that is sufficiently strong to
confront the test as significant. Security lapses can have
devastating effects on big companies, so we need software
engineers to help us safeguard our systems.

6. Testing
Testing has become unbelievably significant as there has been a
tremendous drive in the industry for incrementing standards. And
this is the reason for the further development testing. There are
different kinds of tests. The most vigorous are end-to-end tests
that test how an application coordinates and unit tests that assess
specific functionality.
 ❖ Software development process models :
Software Development life cycle (SDLC) is a spiritual model used in
project management that defines the stages included in an information
system development project, from an initial feasibility study to the
maintenance of the completed application.

There are different software development life cycle models specified

and designed, which are followed during the software development
phase. These models are also called "Software Development Process
Models." Each process model follows a series of phases unique to its
type to ensure success in the step of software development.

Here, are some important phases of SDLC life cycle:

 ❖ What is the SDLC Waterfall Model?
The waterfall model is a software development model used in the
context of large, complex projects, typically in the field of information
technology. It is characterized by a structured, sequential approach to
project management and software development.
The waterfall model is useful in situations where the project
requirements are well-defined and the project goals are clear. It is often
used for large-scale projects with long timelines, where there is little
room for error and the project stakeholders need to have a high level of
confidence in the outcome.

● Features of Waterfall Model

Following are the features of the waterfall model:
1. Sequential Approach: The waterfall model involves a
sequential approach to software development, where each
phase of the project is completed before moving on to the next
one.
2. Document-Driven: The waterfall model depended on

documentation to ensure that the project is well-defined and

the project team is working towards a clear set of goals.
3. Quality Control: The waterfall model places a high emphasis

on quality control and testing at each phase of the project, to

ensure that the final product meets the requirements and
expectations of the stakeholders.
 4. Rigorous Planning: The waterfall model involves a careful
planning process, where the project scope, timelines, and
deliverables are carefully defined and monitored throughout
the project lifecycle.

Overall, the waterfall model is used in situations where there is a need

for a highly structured and systematic approach to software
development. It can be effective in ensuring that large, complex projects
are completed on time and within budget, with a high level of quality
and customer satisfaction.

❖ Importance of Waterfall Model

Following are the importance of waterfall model:
1. Clarity and Simplicity: The linear form of the Waterfall
Model offers a simple and unambiguous foundation for project
development.
2. Clearly Defined Phases: The Waterfall Model phases each
have unique inputs and outputs, guaranteeing a planned
development with obvious checkpoints.
3. Documentation: A focus on thorough documentation helps

with software comprehension, maintenance, and future

growth.
4. Stability in Requirements: Suitable for projects when the
requirements are clear and stable, reducing modifications as
the project progresses.
 5. Resource Optimization: It encourages effective task-
focused work without continuously changing contexts by
allocating resources according to project phases.
6. Relevance for Small Projects: Economical for modest

projects with simple specifications and minimal complexity.

● Phases of Waterfall Model
The Waterfall Model has six phases which are:
1. Requirements: The first phase involves gathering
requirements from stakeholders and analyzing them to
understand the scope and objectives of the project.

2. Design: Once the requirements are understood, the design

phase begins. This involves creating a detailed design

document that outlines the software architecture, user
interface, and system components.

3. Development: The Development phase includes

implementation involving coding the software based on the
design specifications. This phase also includes unit testing to
ensure that each component of the software is working as
expected.

4. Testing: In the testing phase, the software is tested as a whole

to ensure that it meets the requirements and is free from
defects.
 5. Deployment: Once the software has been tested and
approved, it is deployed to the production environment.

6. Maintenance: The final phase of the Waterfall Model is

maintenance, which involves fixing any issues that arise after
the software has been deployed and ensuring that it continues
to meet the requirements over time.

The classical waterfall model divides the life cycle into a set of phases.
This model considers that one phase can be started after the completion
of the previous phase. That is the output of one phase will be the input
to the next phase. Thus the development process can be considered as
a sequential flow in the waterfall. Here the phases do not overlap with
each other. The different sequential phases of the classical waterfall
model are shown in the below figure.
Let us now learn about each of these phases in detail which include
further phases.

1. Feasibility Study

The main goal of this phase is to determine whether it would be

financially and technically feasible to develop the software. The
feasibility study involves understanding the problem and then
determining the various possible strategies to solve the problem. These
different identified solutions are analyzed based on their benefits and
drawbacks. The best solution is chosen and all the other phases are
carried out as per this solution strategy.

2. Requirements Analysis and Specification

The requirement analysis and specification phase aims to understand

the exact requirements of the customer and document them properly.
This phase consists of two different activities.
● Requirement gathering and analysis: Firstly all the
requirements regarding the software are gathered from the
customer and then the gathered requirements are analyzed.
The goal of the analysis part is to remove incompleteness (an
incomplete requirement is one in which some parts of the
actual requirements have been omitted) and inconsistencies
(an inconsistent requirement is one in which some part of the
requirement contradicts some other part).
 ● Requirement specification: These analyzed requirements
are documented in a software requirement specification (SRS)
document. The SRS document serves as a contract between the
development team and customers. Any future dispute between
the customers and the developers can be settled by examining
the SRS document.

3. Design

The goal of this phase is to convert the requirements acquired in the

SRS into a format that can be coded in a programming language. It
includes high-level and detailed design as well as the overall software
architecture. A Software Design Document is used to document all of
this effort (SDD).

4. Coding and Unit Testing

In the coding phase software design is translated into source code using
any suitable programming language. Thus each designed module is
coded. The unit testing phase aims to check whether each module is
working properly or not.

5. Integration and System testing

Integration of different modules is undertaken soon after they have

been coded and unit tested. Integration of various modules is carried
out incrementally over several steps. During each integration step,
previously planned modules are added to the partially integrated
system and the resultant system is tested. Finally, after all the modules
have been successfully integrated and tested, the full working system is
obtained and system testing is carried out on this. System testing
consists of three different kinds of testing activities as described below.
● Alpha testing: Alpha testing is the system testing performed
by the development team.
● Beta testing: Beta testing is the system testing performed by
a friendly set of customers.
● Acceptance testing: After the software has been delivered,

the customer performs acceptance testing to determine

whether to accept the delivered software or reject it.

6. Maintenance

Maintenance is the most important phase of a software life cycle. The

effort spent on maintenance is 60% of the total effort spent to develop
a full software. There are three types of maintenance.
● Corrective Maintenance: This type of maintenance is

carried out to correct errors that were not discovered during the
product development phase.
● Perfective Maintenance: This type of maintenance is
carried out to enhance the functionalities of the system based
on the customer’s request.
● Adaptive Maintenance: Adaptive maintenance is usually
required for porting the software to work in a new environment
 such as working on a new computer platform or with a new
operating system.

❖ Prototyping Model –
Prototyping is defined as the process of developing a working
replication of a product or system that has to be engineered. It offers a
small-scale facsimile of the end product and is used for obtaining
customer feedback. The Prototyping concept is described below:

In this process model, the system is partially implemented before or

during the analysis phase thereby allowing the customers to see the
product early in the life cycle. The process starts by interviewing the
customers and developing the incomplete high-level paper model. This
document is used to build the initial prototype supporting only the basic
functionality as desired by the customer. Once the customer figures out
the problems, the prototype is further refined to eliminate them. The
process continues until the user approves the prototype and finds the
working model to be satisfactory.

● Steps of Prototyping Model

Step 1: Requirement Gathering and Analysis: This is the initial

step in designing a prototype model. In this phase, users are asked
about what they expect or what they want from the system.
Step 2: Quick Design: This is the second step in the Prototyping
Model. This model covers the basic design of the requirement through
which a quick overview can be easily described.
Step 3: Build a Prototype: This step helps in building an actual
prototype from the knowledge gained from prototype design.
Step 4: Initial User Evaluation: This step describes the preliminary
testing where the investigation of the performance model occurs, as the
customer will tell the strengths and weaknesses of the design, which was
sent to the developer.
Step 5: Refining Prototype: If any feedback is given by the user,
then improving the client’s response to feedback and suggestions, the
final system is approved.
Step 6: Implement Product and Maintain: This is the final step
in the phase of the Prototyping Model where the final system is tested
and distributed to production, where the program is run regularly to
prevent failures.
 ❖ Spiral Model
The Spiral Model is one of the most important Software
Development Life Cycle models. The Spiral Model is a combination of
the waterfall model and the iterative model. It provides support for
Risk Handling. The Spiral Model was first proposed by Barry
Boehm. This article focuses on discussing the Spiral Model in detail.

What is the Spiral Model?

The Spiral Model is a Software Development Life Cycle (SDLC)
model that provides a systematic and iterative approach to software
development. In its diagrammatic representation, it looks like a spiral
with many loops. The exact number of loops of the spiral is unknown
and can vary from project to project. Each loop of the spiral is called a
phase of the software development process.
Some Key Points regarding the phase of a Spiral Model:

1. The exact number of phases needed to develop the product can

be varied by the project manager depending upon the project

risks.

2. As the project manager dynamically determines the number of

phases, the project manager has an important role in
developing a product using the spiral model.

3. It is based on the idea of a spiral, with each iteration of the

spiral representing a complete software development cycle,
 from requirements gathering and analysis to design,
implementation, testing, and maintenance.

❖ What Are the Phases of the Spiral

Model?
The Spiral Model is a risk-driven model, meaning that the focus is on
managing risk through multiple iterations of the software development
process. It consists of the following phases:

1. Objectives Defined: In the first phase of the spiral model we

clarify what the project aims to achieve, including functional

and non-functional requirements.

2. Risk Analysis: In the risk analysis phase, the risks associated

with the project are identified and evaluated.

3. Engineering: In the engineering phase, the software is

developed based on the requirements gathered in the previous

iteration.

4. Evaluation: In the evaluation phase, the software is evaluated

to determine if it meets the customer’s requirements and if it is
of high quality.

5. Planning: The next iteration of the spiral begins with a new

planning phase, based on the results of the evaluation.
The Spiral Model is often used for complex and large software
development projects, as it allows for a more flexible and adaptable
approach to software development. It is also well-suited to projects with
significant uncertainty or high levels of risk.

Each phase of the Spiral Model is divided into four quadrants as shown
in the above figure. The functions of these four quadrants are discussed
below:

1. Objective determination and identify alternative

solutions: Requirements are gathered from the customers
and the objectives are identified, elaborated, and analyzed at
the start of every phase. Then alternative solutions possible
for the phase are proposed in this quadrant.
2. Identify and resolve Risks: During the second quadrant, all
the possible solutions are evaluated to select the best possible
solution. Then the risks associated with that solution are
identified and the risks are resolved using the best possible
strategy. At the end of this quadrant, the Prototype is built for
the best possible solution.

3. Develop the next version of the Product: During the third

quadrant, the identified features are developed and verified
through testing. At the end of the third quadrant, the next
version of the software is available.

4. Review and plan for the next Phase: In the fourth

quadrant, the Customers evaluate the so-far developed version
of the software. In the end, planning for the next phase is
started.
 ● Risk Handling in Spiral Model

A risk is any adverse situation that might affect the successful

completion of a software project. The most important feature of the
spiral model is handling these unknown risks after the project has
started. Such risk resolutions are easier done by developing a prototype.

1. The spiral model supports coping with risks by providing the

scope to build a prototype at every phase of software
development.

2. The Prototyping Model also supports risk handling, but the

risks must be identified completely before the start of the

development work of the project.

3. But in real life, project risk may occur after the development
work starts, in that case, we cannot use the Prototyping Model.

4. In each phase of the Spiral Model, the features of the product

are dated and analyzed, and the risks at that point in time are
identified and are resolved through prototyping.

5. Thus, this model is much more flexible compared to other

SDLC models.